sqlglot.parser

   1from __future__ import annotations
   2
   3import itertools
   4import logging
   5import re
   6import typing as t
   7from collections import defaultdict
   8
   9from sqlglot import exp
  10from sqlglot.errors import ErrorLevel, ParseError, TokenError, concat_messages, merge_errors
  11from sqlglot.helper import apply_index_offset, ensure_list, seq_get
  12from sqlglot.time import format_time
  13from sqlglot.tokens import Token, Tokenizer, TokenType
  14from sqlglot.trie import TrieResult, in_trie, new_trie
  15
  16if t.TYPE_CHECKING:
  17    from sqlglot._typing import E, Lit
  18    from sqlglot.dialects.dialect import Dialect, DialectType
  19
  20    T = t.TypeVar("T")
  21    TCeilFloor = t.TypeVar("TCeilFloor", exp.Ceil, exp.Floor)
  22
  23logger = logging.getLogger("sqlglot")
  24
  25OPTIONS_TYPE = t.Dict[str, t.Sequence[t.Union[t.Sequence[str], str]]]
  26
  27# Used to detect alphabetical characters and +/- in timestamp literals
  28TIME_ZONE_RE: t.Pattern[str] = re.compile(r":.*?[a-zA-Z\+\-]")
  29
  30
  31def build_var_map(args: t.List) -> exp.StarMap | exp.VarMap:
  32    if len(args) == 1 and args[0].is_star:
  33        return exp.StarMap(this=args[0])
  34
  35    keys = []
  36    values = []
  37    for i in range(0, len(args), 2):
  38        keys.append(args[i])
  39        values.append(args[i + 1])
  40
  41    return exp.VarMap(keys=exp.array(*keys, copy=False), values=exp.array(*values, copy=False))
  42
  43
  44def build_like(args: t.List) -> exp.Escape | exp.Like:
  45    like = exp.Like(this=seq_get(args, 1), expression=seq_get(args, 0))
  46    return exp.Escape(this=like, expression=seq_get(args, 2)) if len(args) > 2 else like
  47
  48
  49def binary_range_parser(
  50    expr_type: t.Type[exp.Expression], reverse_args: bool = False
  51) -> t.Callable[[Parser, t.Optional[exp.Expression]], t.Optional[exp.Expression]]:
  52    def _parse_binary_range(
  53        self: Parser, this: t.Optional[exp.Expression]
  54    ) -> t.Optional[exp.Expression]:
  55        expression = self._parse_bitwise()
  56        if reverse_args:
  57            this, expression = expression, this
  58        return self._parse_escape(self.expression(expr_type, this=this, expression=expression))
  59
  60    return _parse_binary_range
  61
  62
  63def build_logarithm(args: t.List, dialect: Dialect) -> exp.Func:
  64    # Default argument order is base, expression
  65    this = seq_get(args, 0)
  66    expression = seq_get(args, 1)
  67
  68    if expression:
  69        if not dialect.LOG_BASE_FIRST:
  70            this, expression = expression, this
  71        return exp.Log(this=this, expression=expression)
  72
  73    return (exp.Ln if dialect.parser_class.LOG_DEFAULTS_TO_LN else exp.Log)(this=this)
  74
  75
  76def build_hex(args: t.List, dialect: Dialect) -> exp.Hex | exp.LowerHex:
  77    arg = seq_get(args, 0)
  78    return exp.LowerHex(this=arg) if dialect.HEX_LOWERCASE else exp.Hex(this=arg)
  79
  80
  81def build_lower(args: t.List) -> exp.Lower | exp.Hex:
  82    # LOWER(HEX(..)) can be simplified to LowerHex to simplify its transpilation
  83    arg = seq_get(args, 0)
  84    return exp.LowerHex(this=arg.this) if isinstance(arg, exp.Hex) else exp.Lower(this=arg)
  85
  86
  87def build_upper(args: t.List) -> exp.Upper | exp.Hex:
  88    # UPPER(HEX(..)) can be simplified to Hex to simplify its transpilation
  89    arg = seq_get(args, 0)
  90    return exp.Hex(this=arg.this) if isinstance(arg, exp.Hex) else exp.Upper(this=arg)
  91
  92
  93def build_extract_json_with_path(expr_type: t.Type[E]) -> t.Callable[[t.List, Dialect], E]:
  94    def _builder(args: t.List, dialect: Dialect) -> E:
  95        expression = expr_type(
  96            this=seq_get(args, 0), expression=dialect.to_json_path(seq_get(args, 1))
  97        )
  98        if len(args) > 2 and expr_type is exp.JSONExtract:
  99            expression.set("expressions", args[2:])
 100
 101        return expression
 102
 103    return _builder
 104
 105
 106def build_mod(args: t.List) -> exp.Mod:
 107    this = seq_get(args, 0)
 108    expression = seq_get(args, 1)
 109
 110    # Wrap the operands if they are binary nodes, e.g. MOD(a + 1, 7) -> (a + 1) % 7
 111    this = exp.Paren(this=this) if isinstance(this, exp.Binary) else this
 112    expression = exp.Paren(this=expression) if isinstance(expression, exp.Binary) else expression
 113
 114    return exp.Mod(this=this, expression=expression)
 115
 116
 117def build_pad(args: t.List, is_left: bool = True):
 118    return exp.Pad(
 119        this=seq_get(args, 0),
 120        expression=seq_get(args, 1),
 121        fill_pattern=seq_get(args, 2),
 122        is_left=is_left,
 123    )
 124
 125
 126def build_array_constructor(
 127    exp_class: t.Type[E], args: t.List, bracket_kind: TokenType, dialect: Dialect
 128) -> exp.Expression:
 129    array_exp = exp_class(expressions=args)
 130
 131    if exp_class == exp.Array and dialect.HAS_DISTINCT_ARRAY_CONSTRUCTORS:
 132        array_exp.set("bracket_notation", bracket_kind == TokenType.L_BRACKET)
 133
 134    return array_exp
 135
 136
 137def build_convert_timezone(
 138    args: t.List, default_source_tz: t.Optional[str] = None
 139) -> t.Union[exp.ConvertTimezone, exp.Anonymous]:
 140    if len(args) == 2:
 141        source_tz = exp.Literal.string(default_source_tz) if default_source_tz else None
 142        return exp.ConvertTimezone(
 143            source_tz=source_tz, target_tz=seq_get(args, 0), timestamp=seq_get(args, 1)
 144        )
 145
 146    return exp.ConvertTimezone.from_arg_list(args)
 147
 148
 149def build_trim(args: t.List, is_left: bool = True):
 150    return exp.Trim(
 151        this=seq_get(args, 0),
 152        expression=seq_get(args, 1),
 153        position="LEADING" if is_left else "TRAILING",
 154    )
 155
 156
 157def build_coalesce(
 158    args: t.List, is_nvl: t.Optional[bool] = None, is_null: t.Optional[bool] = None
 159) -> exp.Coalesce:
 160    return exp.Coalesce(this=seq_get(args, 0), expressions=args[1:], is_nvl=is_nvl, is_null=is_null)
 161
 162
 163def build_locate_strposition(args: t.List):
 164    return exp.StrPosition(
 165        this=seq_get(args, 1),
 166        substr=seq_get(args, 0),
 167        position=seq_get(args, 2),
 168    )
 169
 170
 171class _Parser(type):
 172    def __new__(cls, clsname, bases, attrs):
 173        klass = super().__new__(cls, clsname, bases, attrs)
 174
 175        klass.SHOW_TRIE = new_trie(key.split(" ") for key in klass.SHOW_PARSERS)
 176        klass.SET_TRIE = new_trie(key.split(" ") for key in klass.SET_PARSERS)
 177
 178        return klass
 179
 180
 181class Parser(metaclass=_Parser):
 182    """
 183    Parser consumes a list of tokens produced by the Tokenizer and produces a parsed syntax tree.
 184
 185    Args:
 186        error_level: The desired error level.
 187            Default: ErrorLevel.IMMEDIATE
 188        error_message_context: The amount of context to capture from a query string when displaying
 189            the error message (in number of characters).
 190            Default: 100
 191        max_errors: Maximum number of error messages to include in a raised ParseError.
 192            This is only relevant if error_level is ErrorLevel.RAISE.
 193            Default: 3
 194    """
 195
 196    FUNCTIONS: t.Dict[str, t.Callable] = {
 197        **{name: func.from_arg_list for name, func in exp.FUNCTION_BY_NAME.items()},
 198        **dict.fromkeys(("COALESCE", "IFNULL", "NVL"), build_coalesce),
 199        "ARRAY": lambda args, dialect: exp.Array(expressions=args),
 200        "ARRAYAGG": lambda args, dialect: exp.ArrayAgg(
 201            this=seq_get(args, 0), nulls_excluded=dialect.ARRAY_AGG_INCLUDES_NULLS is None or None
 202        ),
 203        "ARRAY_AGG": lambda args, dialect: exp.ArrayAgg(
 204            this=seq_get(args, 0), nulls_excluded=dialect.ARRAY_AGG_INCLUDES_NULLS is None or None
 205        ),
 206        "CHAR": lambda args: exp.Chr(expressions=args),
 207        "CHR": lambda args: exp.Chr(expressions=args),
 208        "COUNT": lambda args: exp.Count(this=seq_get(args, 0), expressions=args[1:], big_int=True),
 209        "CONCAT": lambda args, dialect: exp.Concat(
 210            expressions=args,
 211            safe=not dialect.STRICT_STRING_CONCAT,
 212            coalesce=dialect.CONCAT_COALESCE,
 213        ),
 214        "CONCAT_WS": lambda args, dialect: exp.ConcatWs(
 215            expressions=args,
 216            safe=not dialect.STRICT_STRING_CONCAT,
 217            coalesce=dialect.CONCAT_COALESCE,
 218        ),
 219        "CONVERT_TIMEZONE": build_convert_timezone,
 220        "DATE_TO_DATE_STR": lambda args: exp.Cast(
 221            this=seq_get(args, 0),
 222            to=exp.DataType(this=exp.DataType.Type.TEXT),
 223        ),
 224        "GENERATE_DATE_ARRAY": lambda args: exp.GenerateDateArray(
 225            start=seq_get(args, 0),
 226            end=seq_get(args, 1),
 227            step=seq_get(args, 2) or exp.Interval(this=exp.Literal.string(1), unit=exp.var("DAY")),
 228        ),
 229        "GLOB": lambda args: exp.Glob(this=seq_get(args, 1), expression=seq_get(args, 0)),
 230        "HEX": build_hex,
 231        "JSON_EXTRACT": build_extract_json_with_path(exp.JSONExtract),
 232        "JSON_EXTRACT_SCALAR": build_extract_json_with_path(exp.JSONExtractScalar),
 233        "JSON_EXTRACT_PATH_TEXT": build_extract_json_with_path(exp.JSONExtractScalar),
 234        "LIKE": build_like,
 235        "LOG": build_logarithm,
 236        "LOG2": lambda args: exp.Log(this=exp.Literal.number(2), expression=seq_get(args, 0)),
 237        "LOG10": lambda args: exp.Log(this=exp.Literal.number(10), expression=seq_get(args, 0)),
 238        "LOWER": build_lower,
 239        "LPAD": lambda args: build_pad(args),
 240        "LEFTPAD": lambda args: build_pad(args),
 241        "LTRIM": lambda args: build_trim(args),
 242        "MOD": build_mod,
 243        "RIGHTPAD": lambda args: build_pad(args, is_left=False),
 244        "RPAD": lambda args: build_pad(args, is_left=False),
 245        "RTRIM": lambda args: build_trim(args, is_left=False),
 246        "SCOPE_RESOLUTION": lambda args: exp.ScopeResolution(expression=seq_get(args, 0))
 247        if len(args) != 2
 248        else exp.ScopeResolution(this=seq_get(args, 0), expression=seq_get(args, 1)),
 249        "STRPOS": exp.StrPosition.from_arg_list,
 250        "CHARINDEX": lambda args: build_locate_strposition(args),
 251        "INSTR": exp.StrPosition.from_arg_list,
 252        "LOCATE": lambda args: build_locate_strposition(args),
 253        "TIME_TO_TIME_STR": lambda args: exp.Cast(
 254            this=seq_get(args, 0),
 255            to=exp.DataType(this=exp.DataType.Type.TEXT),
 256        ),
 257        "TO_HEX": build_hex,
 258        "TS_OR_DS_TO_DATE_STR": lambda args: exp.Substring(
 259            this=exp.Cast(
 260                this=seq_get(args, 0),
 261                to=exp.DataType(this=exp.DataType.Type.TEXT),
 262            ),
 263            start=exp.Literal.number(1),
 264            length=exp.Literal.number(10),
 265        ),
 266        "UNNEST": lambda args: exp.Unnest(expressions=ensure_list(seq_get(args, 0))),
 267        "UPPER": build_upper,
 268        "VAR_MAP": build_var_map,
 269    }
 270
 271    NO_PAREN_FUNCTIONS = {
 272        TokenType.CURRENT_DATE: exp.CurrentDate,
 273        TokenType.CURRENT_DATETIME: exp.CurrentDate,
 274        TokenType.CURRENT_TIME: exp.CurrentTime,
 275        TokenType.CURRENT_TIMESTAMP: exp.CurrentTimestamp,
 276        TokenType.CURRENT_USER: exp.CurrentUser,
 277    }
 278
 279    STRUCT_TYPE_TOKENS = {
 280        TokenType.NESTED,
 281        TokenType.OBJECT,
 282        TokenType.STRUCT,
 283        TokenType.UNION,
 284    }
 285
 286    NESTED_TYPE_TOKENS = {
 287        TokenType.ARRAY,
 288        TokenType.LIST,
 289        TokenType.LOWCARDINALITY,
 290        TokenType.MAP,
 291        TokenType.NULLABLE,
 292        TokenType.RANGE,
 293        *STRUCT_TYPE_TOKENS,
 294    }
 295
 296    ENUM_TYPE_TOKENS = {
 297        TokenType.DYNAMIC,
 298        TokenType.ENUM,
 299        TokenType.ENUM8,
 300        TokenType.ENUM16,
 301    }
 302
 303    AGGREGATE_TYPE_TOKENS = {
 304        TokenType.AGGREGATEFUNCTION,
 305        TokenType.SIMPLEAGGREGATEFUNCTION,
 306    }
 307
 308    TYPE_TOKENS = {
 309        TokenType.BIT,
 310        TokenType.BOOLEAN,
 311        TokenType.TINYINT,
 312        TokenType.UTINYINT,
 313        TokenType.SMALLINT,
 314        TokenType.USMALLINT,
 315        TokenType.INT,
 316        TokenType.UINT,
 317        TokenType.BIGINT,
 318        TokenType.UBIGINT,
 319        TokenType.INT128,
 320        TokenType.UINT128,
 321        TokenType.INT256,
 322        TokenType.UINT256,
 323        TokenType.MEDIUMINT,
 324        TokenType.UMEDIUMINT,
 325        TokenType.FIXEDSTRING,
 326        TokenType.FLOAT,
 327        TokenType.DOUBLE,
 328        TokenType.UDOUBLE,
 329        TokenType.CHAR,
 330        TokenType.NCHAR,
 331        TokenType.VARCHAR,
 332        TokenType.NVARCHAR,
 333        TokenType.BPCHAR,
 334        TokenType.TEXT,
 335        TokenType.MEDIUMTEXT,
 336        TokenType.LONGTEXT,
 337        TokenType.BLOB,
 338        TokenType.MEDIUMBLOB,
 339        TokenType.LONGBLOB,
 340        TokenType.BINARY,
 341        TokenType.VARBINARY,
 342        TokenType.JSON,
 343        TokenType.JSONB,
 344        TokenType.INTERVAL,
 345        TokenType.TINYBLOB,
 346        TokenType.TINYTEXT,
 347        TokenType.TIME,
 348        TokenType.TIMETZ,
 349        TokenType.TIMESTAMP,
 350        TokenType.TIMESTAMP_S,
 351        TokenType.TIMESTAMP_MS,
 352        TokenType.TIMESTAMP_NS,
 353        TokenType.TIMESTAMPTZ,
 354        TokenType.TIMESTAMPLTZ,
 355        TokenType.TIMESTAMPNTZ,
 356        TokenType.DATETIME,
 357        TokenType.DATETIME2,
 358        TokenType.DATETIME64,
 359        TokenType.SMALLDATETIME,
 360        TokenType.DATE,
 361        TokenType.DATE32,
 362        TokenType.INT4RANGE,
 363        TokenType.INT4MULTIRANGE,
 364        TokenType.INT8RANGE,
 365        TokenType.INT8MULTIRANGE,
 366        TokenType.NUMRANGE,
 367        TokenType.NUMMULTIRANGE,
 368        TokenType.TSRANGE,
 369        TokenType.TSMULTIRANGE,
 370        TokenType.TSTZRANGE,
 371        TokenType.TSTZMULTIRANGE,
 372        TokenType.DATERANGE,
 373        TokenType.DATEMULTIRANGE,
 374        TokenType.DECIMAL,
 375        TokenType.DECIMAL32,
 376        TokenType.DECIMAL64,
 377        TokenType.DECIMAL128,
 378        TokenType.DECIMAL256,
 379        TokenType.UDECIMAL,
 380        TokenType.BIGDECIMAL,
 381        TokenType.UUID,
 382        TokenType.GEOGRAPHY,
 383        TokenType.GEOGRAPHYPOINT,
 384        TokenType.GEOMETRY,
 385        TokenType.POINT,
 386        TokenType.RING,
 387        TokenType.LINESTRING,
 388        TokenType.MULTILINESTRING,
 389        TokenType.POLYGON,
 390        TokenType.MULTIPOLYGON,
 391        TokenType.HLLSKETCH,
 392        TokenType.HSTORE,
 393        TokenType.PSEUDO_TYPE,
 394        TokenType.SUPER,
 395        TokenType.SERIAL,
 396        TokenType.SMALLSERIAL,
 397        TokenType.BIGSERIAL,
 398        TokenType.XML,
 399        TokenType.YEAR,
 400        TokenType.USERDEFINED,
 401        TokenType.MONEY,
 402        TokenType.SMALLMONEY,
 403        TokenType.ROWVERSION,
 404        TokenType.IMAGE,
 405        TokenType.VARIANT,
 406        TokenType.VECTOR,
 407        TokenType.VOID,
 408        TokenType.OBJECT,
 409        TokenType.OBJECT_IDENTIFIER,
 410        TokenType.INET,
 411        TokenType.IPADDRESS,
 412        TokenType.IPPREFIX,
 413        TokenType.IPV4,
 414        TokenType.IPV6,
 415        TokenType.UNKNOWN,
 416        TokenType.NOTHING,
 417        TokenType.NULL,
 418        TokenType.NAME,
 419        TokenType.TDIGEST,
 420        TokenType.DYNAMIC,
 421        *ENUM_TYPE_TOKENS,
 422        *NESTED_TYPE_TOKENS,
 423        *AGGREGATE_TYPE_TOKENS,
 424    }
 425
 426    SIGNED_TO_UNSIGNED_TYPE_TOKEN = {
 427        TokenType.BIGINT: TokenType.UBIGINT,
 428        TokenType.INT: TokenType.UINT,
 429        TokenType.MEDIUMINT: TokenType.UMEDIUMINT,
 430        TokenType.SMALLINT: TokenType.USMALLINT,
 431        TokenType.TINYINT: TokenType.UTINYINT,
 432        TokenType.DECIMAL: TokenType.UDECIMAL,
 433        TokenType.DOUBLE: TokenType.UDOUBLE,
 434    }
 435
 436    SUBQUERY_PREDICATES = {
 437        TokenType.ANY: exp.Any,
 438        TokenType.ALL: exp.All,
 439        TokenType.EXISTS: exp.Exists,
 440        TokenType.SOME: exp.Any,
 441    }
 442
 443    RESERVED_TOKENS = {
 444        *Tokenizer.SINGLE_TOKENS.values(),
 445        TokenType.SELECT,
 446    } - {TokenType.IDENTIFIER}
 447
 448    DB_CREATABLES = {
 449        TokenType.DATABASE,
 450        TokenType.DICTIONARY,
 451        TokenType.FILE_FORMAT,
 452        TokenType.MODEL,
 453        TokenType.NAMESPACE,
 454        TokenType.SCHEMA,
 455        TokenType.SEMANTIC_VIEW,
 456        TokenType.SEQUENCE,
 457        TokenType.SINK,
 458        TokenType.SOURCE,
 459        TokenType.STAGE,
 460        TokenType.STORAGE_INTEGRATION,
 461        TokenType.STREAMLIT,
 462        TokenType.TABLE,
 463        TokenType.TAG,
 464        TokenType.VIEW,
 465        TokenType.WAREHOUSE,
 466    }
 467
 468    CREATABLES = {
 469        TokenType.COLUMN,
 470        TokenType.CONSTRAINT,
 471        TokenType.FOREIGN_KEY,
 472        TokenType.FUNCTION,
 473        TokenType.INDEX,
 474        TokenType.PROCEDURE,
 475        *DB_CREATABLES,
 476    }
 477
 478    ALTERABLES = {
 479        TokenType.INDEX,
 480        TokenType.TABLE,
 481        TokenType.VIEW,
 482        TokenType.SESSION,
 483    }
 484
 485    # Tokens that can represent identifiers
 486    ID_VAR_TOKENS = {
 487        TokenType.ALL,
 488        TokenType.ATTACH,
 489        TokenType.VAR,
 490        TokenType.ANTI,
 491        TokenType.APPLY,
 492        TokenType.ASC,
 493        TokenType.ASOF,
 494        TokenType.AUTO_INCREMENT,
 495        TokenType.BEGIN,
 496        TokenType.BPCHAR,
 497        TokenType.CACHE,
 498        TokenType.CASE,
 499        TokenType.COLLATE,
 500        TokenType.COMMAND,
 501        TokenType.COMMENT,
 502        TokenType.COMMIT,
 503        TokenType.CONSTRAINT,
 504        TokenType.COPY,
 505        TokenType.CUBE,
 506        TokenType.CURRENT_SCHEMA,
 507        TokenType.DEFAULT,
 508        TokenType.DELETE,
 509        TokenType.DESC,
 510        TokenType.DESCRIBE,
 511        TokenType.DETACH,
 512        TokenType.DICTIONARY,
 513        TokenType.DIV,
 514        TokenType.END,
 515        TokenType.EXECUTE,
 516        TokenType.EXPORT,
 517        TokenType.ESCAPE,
 518        TokenType.FALSE,
 519        TokenType.FIRST,
 520        TokenType.FILTER,
 521        TokenType.FINAL,
 522        TokenType.FORMAT,
 523        TokenType.FULL,
 524        TokenType.GET,
 525        TokenType.IDENTIFIER,
 526        TokenType.IS,
 527        TokenType.ISNULL,
 528        TokenType.INTERVAL,
 529        TokenType.KEEP,
 530        TokenType.KILL,
 531        TokenType.LEFT,
 532        TokenType.LIMIT,
 533        TokenType.LOAD,
 534        TokenType.LOCK,
 535        TokenType.MERGE,
 536        TokenType.NATURAL,
 537        TokenType.NEXT,
 538        TokenType.OFFSET,
 539        TokenType.OPERATOR,
 540        TokenType.ORDINALITY,
 541        TokenType.OVERLAPS,
 542        TokenType.OVERWRITE,
 543        TokenType.PARTITION,
 544        TokenType.PERCENT,
 545        TokenType.PIVOT,
 546        TokenType.PRAGMA,
 547        TokenType.PUT,
 548        TokenType.RANGE,
 549        TokenType.RECURSIVE,
 550        TokenType.REFERENCES,
 551        TokenType.REFRESH,
 552        TokenType.RENAME,
 553        TokenType.REPLACE,
 554        TokenType.RIGHT,
 555        TokenType.ROLLUP,
 556        TokenType.ROW,
 557        TokenType.ROWS,
 558        TokenType.SEMI,
 559        TokenType.SET,
 560        TokenType.SETTINGS,
 561        TokenType.SHOW,
 562        TokenType.TEMPORARY,
 563        TokenType.TOP,
 564        TokenType.TRUE,
 565        TokenType.TRUNCATE,
 566        TokenType.UNIQUE,
 567        TokenType.UNNEST,
 568        TokenType.UNPIVOT,
 569        TokenType.UPDATE,
 570        TokenType.USE,
 571        TokenType.VOLATILE,
 572        TokenType.WINDOW,
 573        *ALTERABLES,
 574        *CREATABLES,
 575        *SUBQUERY_PREDICATES,
 576        *TYPE_TOKENS,
 577        *NO_PAREN_FUNCTIONS,
 578    }
 579    ID_VAR_TOKENS.remove(TokenType.UNION)
 580
 581    TABLE_ALIAS_TOKENS = ID_VAR_TOKENS - {
 582        TokenType.ANTI,
 583        TokenType.ASOF,
 584        TokenType.FULL,
 585        TokenType.LEFT,
 586        TokenType.LOCK,
 587        TokenType.NATURAL,
 588        TokenType.RIGHT,
 589        TokenType.SEMI,
 590        TokenType.WINDOW,
 591    }
 592
 593    ALIAS_TOKENS = ID_VAR_TOKENS
 594
 595    COLON_PLACEHOLDER_TOKENS = ID_VAR_TOKENS
 596
 597    ARRAY_CONSTRUCTORS = {
 598        "ARRAY": exp.Array,
 599        "LIST": exp.List,
 600    }
 601
 602    COMMENT_TABLE_ALIAS_TOKENS = TABLE_ALIAS_TOKENS - {TokenType.IS}
 603
 604    UPDATE_ALIAS_TOKENS = TABLE_ALIAS_TOKENS - {TokenType.SET}
 605
 606    TRIM_TYPES = {"LEADING", "TRAILING", "BOTH"}
 607
 608    FUNC_TOKENS = {
 609        TokenType.COLLATE,
 610        TokenType.COMMAND,
 611        TokenType.CURRENT_DATE,
 612        TokenType.CURRENT_DATETIME,
 613        TokenType.CURRENT_SCHEMA,
 614        TokenType.CURRENT_TIMESTAMP,
 615        TokenType.CURRENT_TIME,
 616        TokenType.CURRENT_USER,
 617        TokenType.FILTER,
 618        TokenType.FIRST,
 619        TokenType.FORMAT,
 620        TokenType.GET,
 621        TokenType.GLOB,
 622        TokenType.IDENTIFIER,
 623        TokenType.INDEX,
 624        TokenType.ISNULL,
 625        TokenType.ILIKE,
 626        TokenType.INSERT,
 627        TokenType.LIKE,
 628        TokenType.MERGE,
 629        TokenType.NEXT,
 630        TokenType.OFFSET,
 631        TokenType.PRIMARY_KEY,
 632        TokenType.RANGE,
 633        TokenType.REPLACE,
 634        TokenType.RLIKE,
 635        TokenType.ROW,
 636        TokenType.UNNEST,
 637        TokenType.VAR,
 638        TokenType.LEFT,
 639        TokenType.RIGHT,
 640        TokenType.SEQUENCE,
 641        TokenType.DATE,
 642        TokenType.DATETIME,
 643        TokenType.TABLE,
 644        TokenType.TIMESTAMP,
 645        TokenType.TIMESTAMPTZ,
 646        TokenType.TRUNCATE,
 647        TokenType.UTC_DATE,
 648        TokenType.UTC_TIME,
 649        TokenType.UTC_TIMESTAMP,
 650        TokenType.WINDOW,
 651        TokenType.XOR,
 652        *TYPE_TOKENS,
 653        *SUBQUERY_PREDICATES,
 654    }
 655
 656    CONJUNCTION: t.Dict[TokenType, t.Type[exp.Expression]] = {
 657        TokenType.AND: exp.And,
 658    }
 659
 660    ASSIGNMENT: t.Dict[TokenType, t.Type[exp.Expression]] = {
 661        TokenType.COLON_EQ: exp.PropertyEQ,
 662    }
 663
 664    DISJUNCTION: t.Dict[TokenType, t.Type[exp.Expression]] = {
 665        TokenType.OR: exp.Or,
 666    }
 667
 668    EQUALITY = {
 669        TokenType.EQ: exp.EQ,
 670        TokenType.NEQ: exp.NEQ,
 671        TokenType.NULLSAFE_EQ: exp.NullSafeEQ,
 672    }
 673
 674    COMPARISON = {
 675        TokenType.GT: exp.GT,
 676        TokenType.GTE: exp.GTE,
 677        TokenType.LT: exp.LT,
 678        TokenType.LTE: exp.LTE,
 679    }
 680
 681    BITWISE = {
 682        TokenType.AMP: exp.BitwiseAnd,
 683        TokenType.CARET: exp.BitwiseXor,
 684        TokenType.PIPE: exp.BitwiseOr,
 685    }
 686
 687    TERM = {
 688        TokenType.DASH: exp.Sub,
 689        TokenType.PLUS: exp.Add,
 690        TokenType.MOD: exp.Mod,
 691        TokenType.COLLATE: exp.Collate,
 692    }
 693
 694    FACTOR = {
 695        TokenType.DIV: exp.IntDiv,
 696        TokenType.LR_ARROW: exp.Distance,
 697        TokenType.SLASH: exp.Div,
 698        TokenType.STAR: exp.Mul,
 699    }
 700
 701    EXPONENT: t.Dict[TokenType, t.Type[exp.Expression]] = {}
 702
 703    TIMES = {
 704        TokenType.TIME,
 705        TokenType.TIMETZ,
 706    }
 707
 708    TIMESTAMPS = {
 709        TokenType.TIMESTAMP,
 710        TokenType.TIMESTAMPNTZ,
 711        TokenType.TIMESTAMPTZ,
 712        TokenType.TIMESTAMPLTZ,
 713        *TIMES,
 714    }
 715
 716    SET_OPERATIONS = {
 717        TokenType.UNION,
 718        TokenType.INTERSECT,
 719        TokenType.EXCEPT,
 720    }
 721
 722    JOIN_METHODS = {
 723        TokenType.ASOF,
 724        TokenType.NATURAL,
 725        TokenType.POSITIONAL,
 726    }
 727
 728    JOIN_SIDES = {
 729        TokenType.LEFT,
 730        TokenType.RIGHT,
 731        TokenType.FULL,
 732    }
 733
 734    JOIN_KINDS = {
 735        TokenType.ANTI,
 736        TokenType.CROSS,
 737        TokenType.INNER,
 738        TokenType.OUTER,
 739        TokenType.SEMI,
 740        TokenType.STRAIGHT_JOIN,
 741    }
 742
 743    JOIN_HINTS: t.Set[str] = set()
 744
 745    LAMBDAS = {
 746        TokenType.ARROW: lambda self, expressions: self.expression(
 747            exp.Lambda,
 748            this=self._replace_lambda(
 749                self._parse_assignment(),
 750                expressions,
 751            ),
 752            expressions=expressions,
 753        ),
 754        TokenType.FARROW: lambda self, expressions: self.expression(
 755            exp.Kwarg,
 756            this=exp.var(expressions[0].name),
 757            expression=self._parse_assignment(),
 758        ),
 759    }
 760
 761    COLUMN_OPERATORS = {
 762        TokenType.DOT: None,
 763        TokenType.DOTCOLON: lambda self, this, to: self.expression(
 764            exp.JSONCast,
 765            this=this,
 766            to=to,
 767        ),
 768        TokenType.DCOLON: lambda self, this, to: self.build_cast(
 769            strict=self.STRICT_CAST, this=this, to=to
 770        ),
 771        TokenType.ARROW: lambda self, this, path: self.expression(
 772            exp.JSONExtract,
 773            this=this,
 774            expression=self.dialect.to_json_path(path),
 775            only_json_types=self.JSON_ARROWS_REQUIRE_JSON_TYPE,
 776        ),
 777        TokenType.DARROW: lambda self, this, path: self.expression(
 778            exp.JSONExtractScalar,
 779            this=this,
 780            expression=self.dialect.to_json_path(path),
 781            only_json_types=self.JSON_ARROWS_REQUIRE_JSON_TYPE,
 782        ),
 783        TokenType.HASH_ARROW: lambda self, this, path: self.expression(
 784            exp.JSONBExtract,
 785            this=this,
 786            expression=path,
 787        ),
 788        TokenType.DHASH_ARROW: lambda self, this, path: self.expression(
 789            exp.JSONBExtractScalar,
 790            this=this,
 791            expression=path,
 792        ),
 793        TokenType.PLACEHOLDER: lambda self, this, key: self.expression(
 794            exp.JSONBContains,
 795            this=this,
 796            expression=key,
 797        ),
 798    }
 799
 800    CAST_COLUMN_OPERATORS = {
 801        TokenType.DOTCOLON,
 802        TokenType.DCOLON,
 803    }
 804
 805    EXPRESSION_PARSERS = {
 806        exp.Cluster: lambda self: self._parse_sort(exp.Cluster, TokenType.CLUSTER_BY),
 807        exp.Column: lambda self: self._parse_column(),
 808        exp.Condition: lambda self: self._parse_assignment(),
 809        exp.DataType: lambda self: self._parse_types(allow_identifiers=False, schema=True),
 810        exp.Expression: lambda self: self._parse_expression(),
 811        exp.From: lambda self: self._parse_from(joins=True),
 812        exp.GrantPrincipal: lambda self: self._parse_grant_principal(),
 813        exp.GrantPrivilege: lambda self: self._parse_grant_privilege(),
 814        exp.Group: lambda self: self._parse_group(),
 815        exp.Having: lambda self: self._parse_having(),
 816        exp.Hint: lambda self: self._parse_hint_body(),
 817        exp.Identifier: lambda self: self._parse_id_var(),
 818        exp.Join: lambda self: self._parse_join(),
 819        exp.Lambda: lambda self: self._parse_lambda(),
 820        exp.Lateral: lambda self: self._parse_lateral(),
 821        exp.Limit: lambda self: self._parse_limit(),
 822        exp.Offset: lambda self: self._parse_offset(),
 823        exp.Order: lambda self: self._parse_order(),
 824        exp.Ordered: lambda self: self._parse_ordered(),
 825        exp.Properties: lambda self: self._parse_properties(),
 826        exp.PartitionedByProperty: lambda self: self._parse_partitioned_by(),
 827        exp.Qualify: lambda self: self._parse_qualify(),
 828        exp.Returning: lambda self: self._parse_returning(),
 829        exp.Select: lambda self: self._parse_select(),
 830        exp.Sort: lambda self: self._parse_sort(exp.Sort, TokenType.SORT_BY),
 831        exp.Table: lambda self: self._parse_table_parts(),
 832        exp.TableAlias: lambda self: self._parse_table_alias(),
 833        exp.Tuple: lambda self: self._parse_value(values=False),
 834        exp.Whens: lambda self: self._parse_when_matched(),
 835        exp.Where: lambda self: self._parse_where(),
 836        exp.Window: lambda self: self._parse_named_window(),
 837        exp.With: lambda self: self._parse_with(),
 838        "JOIN_TYPE": lambda self: self._parse_join_parts(),
 839    }
 840
 841    STATEMENT_PARSERS = {
 842        TokenType.ALTER: lambda self: self._parse_alter(),
 843        TokenType.ANALYZE: lambda self: self._parse_analyze(),
 844        TokenType.BEGIN: lambda self: self._parse_transaction(),
 845        TokenType.CACHE: lambda self: self._parse_cache(),
 846        TokenType.COMMENT: lambda self: self._parse_comment(),
 847        TokenType.COMMIT: lambda self: self._parse_commit_or_rollback(),
 848        TokenType.COPY: lambda self: self._parse_copy(),
 849        TokenType.CREATE: lambda self: self._parse_create(),
 850        TokenType.DELETE: lambda self: self._parse_delete(),
 851        TokenType.DESC: lambda self: self._parse_describe(),
 852        TokenType.DESCRIBE: lambda self: self._parse_describe(),
 853        TokenType.DROP: lambda self: self._parse_drop(),
 854        TokenType.GRANT: lambda self: self._parse_grant(),
 855        TokenType.REVOKE: lambda self: self._parse_revoke(),
 856        TokenType.INSERT: lambda self: self._parse_insert(),
 857        TokenType.KILL: lambda self: self._parse_kill(),
 858        TokenType.LOAD: lambda self: self._parse_load(),
 859        TokenType.MERGE: lambda self: self._parse_merge(),
 860        TokenType.PIVOT: lambda self: self._parse_simplified_pivot(),
 861        TokenType.PRAGMA: lambda self: self.expression(exp.Pragma, this=self._parse_expression()),
 862        TokenType.REFRESH: lambda self: self._parse_refresh(),
 863        TokenType.ROLLBACK: lambda self: self._parse_commit_or_rollback(),
 864        TokenType.SET: lambda self: self._parse_set(),
 865        TokenType.TRUNCATE: lambda self: self._parse_truncate_table(),
 866        TokenType.UNCACHE: lambda self: self._parse_uncache(),
 867        TokenType.UNPIVOT: lambda self: self._parse_simplified_pivot(is_unpivot=True),
 868        TokenType.UPDATE: lambda self: self._parse_update(),
 869        TokenType.USE: lambda self: self._parse_use(),
 870        TokenType.SEMICOLON: lambda self: exp.Semicolon(),
 871    }
 872
 873    UNARY_PARSERS = {
 874        TokenType.PLUS: lambda self: self._parse_unary(),  # Unary + is handled as a no-op
 875        TokenType.NOT: lambda self: self.expression(exp.Not, this=self._parse_equality()),
 876        TokenType.TILDA: lambda self: self.expression(exp.BitwiseNot, this=self._parse_unary()),
 877        TokenType.DASH: lambda self: self.expression(exp.Neg, this=self._parse_unary()),
 878        TokenType.PIPE_SLASH: lambda self: self.expression(exp.Sqrt, this=self._parse_unary()),
 879        TokenType.DPIPE_SLASH: lambda self: self.expression(exp.Cbrt, this=self._parse_unary()),
 880    }
 881
 882    STRING_PARSERS = {
 883        TokenType.HEREDOC_STRING: lambda self, token: self.expression(
 884            exp.RawString, this=token.text
 885        ),
 886        TokenType.NATIONAL_STRING: lambda self, token: self.expression(
 887            exp.National, this=token.text
 888        ),
 889        TokenType.RAW_STRING: lambda self, token: self.expression(exp.RawString, this=token.text),
 890        TokenType.STRING: lambda self, token: self.expression(
 891            exp.Literal, this=token.text, is_string=True
 892        ),
 893        TokenType.UNICODE_STRING: lambda self, token: self.expression(
 894            exp.UnicodeString,
 895            this=token.text,
 896            escape=self._match_text_seq("UESCAPE") and self._parse_string(),
 897        ),
 898    }
 899
 900    NUMERIC_PARSERS = {
 901        TokenType.BIT_STRING: lambda self, token: self.expression(exp.BitString, this=token.text),
 902        TokenType.BYTE_STRING: lambda self, token: self.expression(exp.ByteString, this=token.text),
 903        TokenType.HEX_STRING: lambda self, token: self.expression(
 904            exp.HexString,
 905            this=token.text,
 906            is_integer=self.dialect.HEX_STRING_IS_INTEGER_TYPE or None,
 907        ),
 908        TokenType.NUMBER: lambda self, token: self.expression(
 909            exp.Literal, this=token.text, is_string=False
 910        ),
 911    }
 912
 913    PRIMARY_PARSERS = {
 914        **STRING_PARSERS,
 915        **NUMERIC_PARSERS,
 916        TokenType.INTRODUCER: lambda self, token: self._parse_introducer(token),
 917        TokenType.NULL: lambda self, _: self.expression(exp.Null),
 918        TokenType.TRUE: lambda self, _: self.expression(exp.Boolean, this=True),
 919        TokenType.FALSE: lambda self, _: self.expression(exp.Boolean, this=False),
 920        TokenType.SESSION_PARAMETER: lambda self, _: self._parse_session_parameter(),
 921        TokenType.STAR: lambda self, _: self._parse_star_ops(),
 922    }
 923
 924    PLACEHOLDER_PARSERS = {
 925        TokenType.PLACEHOLDER: lambda self: self.expression(exp.Placeholder),
 926        TokenType.PARAMETER: lambda self: self._parse_parameter(),
 927        TokenType.COLON: lambda self: (
 928            self.expression(exp.Placeholder, this=self._prev.text)
 929            if self._match_set(self.COLON_PLACEHOLDER_TOKENS)
 930            else None
 931        ),
 932    }
 933
 934    RANGE_PARSERS = {
 935        TokenType.AT_GT: binary_range_parser(exp.ArrayContainsAll),
 936        TokenType.BETWEEN: lambda self, this: self._parse_between(this),
 937        TokenType.GLOB: binary_range_parser(exp.Glob),
 938        TokenType.ILIKE: binary_range_parser(exp.ILike),
 939        TokenType.IN: lambda self, this: self._parse_in(this),
 940        TokenType.IRLIKE: binary_range_parser(exp.RegexpILike),
 941        TokenType.IS: lambda self, this: self._parse_is(this),
 942        TokenType.LIKE: binary_range_parser(exp.Like),
 943        TokenType.LT_AT: binary_range_parser(exp.ArrayContainsAll, reverse_args=True),
 944        TokenType.OVERLAPS: binary_range_parser(exp.Overlaps),
 945        TokenType.RLIKE: binary_range_parser(exp.RegexpLike),
 946        TokenType.SIMILAR_TO: binary_range_parser(exp.SimilarTo),
 947        TokenType.FOR: lambda self, this: self._parse_comprehension(this),
 948        TokenType.QMARK_AMP: binary_range_parser(exp.JSONBContainsAllTopKeys),
 949        TokenType.QMARK_PIPE: binary_range_parser(exp.JSONBContainsAnyTopKeys),
 950        TokenType.HASH_DASH: binary_range_parser(exp.JSONBDeleteAtPath),
 951    }
 952
 953    PIPE_SYNTAX_TRANSFORM_PARSERS = {
 954        "AGGREGATE": lambda self, query: self._parse_pipe_syntax_aggregate(query),
 955        "AS": lambda self, query: self._build_pipe_cte(
 956            query, [exp.Star()], self._parse_table_alias()
 957        ),
 958        "EXTEND": lambda self, query: self._parse_pipe_syntax_extend(query),
 959        "LIMIT": lambda self, query: self._parse_pipe_syntax_limit(query),
 960        "ORDER BY": lambda self, query: query.order_by(
 961            self._parse_order(), append=False, copy=False
 962        ),
 963        "PIVOT": lambda self, query: self._parse_pipe_syntax_pivot(query),
 964        "SELECT": lambda self, query: self._parse_pipe_syntax_select(query),
 965        "TABLESAMPLE": lambda self, query: self._parse_pipe_syntax_tablesample(query),
 966        "UNPIVOT": lambda self, query: self._parse_pipe_syntax_pivot(query),
 967        "WHERE": lambda self, query: query.where(self._parse_where(), copy=False),
 968    }
 969
 970    PROPERTY_PARSERS: t.Dict[str, t.Callable] = {
 971        "ALLOWED_VALUES": lambda self: self.expression(
 972            exp.AllowedValuesProperty, expressions=self._parse_csv(self._parse_primary)
 973        ),
 974        "ALGORITHM": lambda self: self._parse_property_assignment(exp.AlgorithmProperty),
 975        "AUTO": lambda self: self._parse_auto_property(),
 976        "AUTO_INCREMENT": lambda self: self._parse_property_assignment(exp.AutoIncrementProperty),
 977        "BACKUP": lambda self: self.expression(
 978            exp.BackupProperty, this=self._parse_var(any_token=True)
 979        ),
 980        "BLOCKCOMPRESSION": lambda self: self._parse_blockcompression(),
 981        "CHARSET": lambda self, **kwargs: self._parse_character_set(**kwargs),
 982        "CHARACTER SET": lambda self, **kwargs: self._parse_character_set(**kwargs),
 983        "CHECKSUM": lambda self: self._parse_checksum(),
 984        "CLUSTER BY": lambda self: self._parse_cluster(),
 985        "CLUSTERED": lambda self: self._parse_clustered_by(),
 986        "COLLATE": lambda self, **kwargs: self._parse_property_assignment(
 987            exp.CollateProperty, **kwargs
 988        ),
 989        "COMMENT": lambda self: self._parse_property_assignment(exp.SchemaCommentProperty),
 990        "CONTAINS": lambda self: self._parse_contains_property(),
 991        "COPY": lambda self: self._parse_copy_property(),
 992        "DATABLOCKSIZE": lambda self, **kwargs: self._parse_datablocksize(**kwargs),
 993        "DATA_DELETION": lambda self: self._parse_data_deletion_property(),
 994        "DEFINER": lambda self: self._parse_definer(),
 995        "DETERMINISTIC": lambda self: self.expression(
 996            exp.StabilityProperty, this=exp.Literal.string("IMMUTABLE")
 997        ),
 998        "DISTRIBUTED": lambda self: self._parse_distributed_property(),
 999        "DUPLICATE": lambda self: self._parse_composite_key_property(exp.DuplicateKeyProperty),
1000        "DYNAMIC": lambda self: self.expression(exp.DynamicProperty),
1001        "DISTKEY": lambda self: self._parse_distkey(),
1002        "DISTSTYLE": lambda self: self._parse_property_assignment(exp.DistStyleProperty),
1003        "EMPTY": lambda self: self.expression(exp.EmptyProperty),
1004        "ENGINE": lambda self: self._parse_property_assignment(exp.EngineProperty),
1005        "ENVIRONMENT": lambda self: self.expression(
1006            exp.EnviromentProperty, expressions=self._parse_wrapped_csv(self._parse_assignment)
1007        ),
1008        "EXECUTE": lambda self: self._parse_property_assignment(exp.ExecuteAsProperty),
1009        "EXTERNAL": lambda self: self.expression(exp.ExternalProperty),
1010        "FALLBACK": lambda self, **kwargs: self._parse_fallback(**kwargs),
1011        "FORMAT": lambda self: self._parse_property_assignment(exp.FileFormatProperty),
1012        "FREESPACE": lambda self: self._parse_freespace(),
1013        "GLOBAL": lambda self: self.expression(exp.GlobalProperty),
1014        "HEAP": lambda self: self.expression(exp.HeapProperty),
1015        "ICEBERG": lambda self: self.expression(exp.IcebergProperty),
1016        "IMMUTABLE": lambda self: self.expression(
1017            exp.StabilityProperty, this=exp.Literal.string("IMMUTABLE")
1018        ),
1019        "INHERITS": lambda self: self.expression(
1020            exp.InheritsProperty, expressions=self._parse_wrapped_csv(self._parse_table)
1021        ),
1022        "INPUT": lambda self: self.expression(exp.InputModelProperty, this=self._parse_schema()),
1023        "JOURNAL": lambda self, **kwargs: self._parse_journal(**kwargs),
1024        "LANGUAGE": lambda self: self._parse_property_assignment(exp.LanguageProperty),
1025        "LAYOUT": lambda self: self._parse_dict_property(this="LAYOUT"),
1026        "LIFETIME": lambda self: self._parse_dict_range(this="LIFETIME"),
1027        "LIKE": lambda self: self._parse_create_like(),
1028        "LOCATION": lambda self: self._parse_property_assignment(exp.LocationProperty),
1029        "LOCK": lambda self: self._parse_locking(),
1030        "LOCKING": lambda self: self._parse_locking(),
1031        "LOG": lambda self, **kwargs: self._parse_log(**kwargs),
1032        "MATERIALIZED": lambda self: self.expression(exp.MaterializedProperty),
1033        "MERGEBLOCKRATIO": lambda self, **kwargs: self._parse_mergeblockratio(**kwargs),
1034        "MODIFIES": lambda self: self._parse_modifies_property(),
1035        "MULTISET": lambda self: self.expression(exp.SetProperty, multi=True),
1036        "NO": lambda self: self._parse_no_property(),
1037        "ON": lambda self: self._parse_on_property(),
1038        "ORDER BY": lambda self: self._parse_order(skip_order_token=True),
1039        "OUTPUT": lambda self: self.expression(exp.OutputModelProperty, this=self._parse_schema()),
1040        "PARTITION": lambda self: self._parse_partitioned_of(),
1041        "PARTITION BY": lambda self: self._parse_partitioned_by(),
1042        "PARTITIONED BY": lambda self: self._parse_partitioned_by(),
1043        "PARTITIONED_BY": lambda self: self._parse_partitioned_by(),
1044        "PRIMARY KEY": lambda self: self._parse_primary_key(in_props=True),
1045        "RANGE": lambda self: self._parse_dict_range(this="RANGE"),
1046        "READS": lambda self: self._parse_reads_property(),
1047        "REMOTE": lambda self: self._parse_remote_with_connection(),
1048        "RETURNS": lambda self: self._parse_returns(),
1049        "STRICT": lambda self: self.expression(exp.StrictProperty),
1050        "STREAMING": lambda self: self.expression(exp.StreamingTableProperty),
1051        "ROW": lambda self: self._parse_row(),
1052        "ROW_FORMAT": lambda self: self._parse_property_assignment(exp.RowFormatProperty),
1053        "SAMPLE": lambda self: self.expression(
1054            exp.SampleProperty, this=self._match_text_seq("BY") and self._parse_bitwise()
1055        ),
1056        "SECURE": lambda self: self.expression(exp.SecureProperty),
1057        "SECURITY": lambda self: self._parse_security(),
1058        "SET": lambda self: self.expression(exp.SetProperty, multi=False),
1059        "SETTINGS": lambda self: self._parse_settings_property(),
1060        "SHARING": lambda self: self._parse_property_assignment(exp.SharingProperty),
1061        "SORTKEY": lambda self: self._parse_sortkey(),
1062        "SOURCE": lambda self: self._parse_dict_property(this="SOURCE"),
1063        "STABLE": lambda self: self.expression(
1064            exp.StabilityProperty, this=exp.Literal.string("STABLE")
1065        ),
1066        "STORED": lambda self: self._parse_stored(),
1067        "SYSTEM_VERSIONING": lambda self: self._parse_system_versioning_property(),
1068        "TBLPROPERTIES": lambda self: self._parse_wrapped_properties(),
1069        "TEMP": lambda self: self.expression(exp.TemporaryProperty),
1070        "TEMPORARY": lambda self: self.expression(exp.TemporaryProperty),
1071        "TO": lambda self: self._parse_to_table(),
1072        "TRANSIENT": lambda self: self.expression(exp.TransientProperty),
1073        "TRANSFORM": lambda self: self.expression(
1074            exp.TransformModelProperty, expressions=self._parse_wrapped_csv(self._parse_expression)
1075        ),
1076        "TTL": lambda self: self._parse_ttl(),
1077        "USING": lambda self: self._parse_property_assignment(exp.FileFormatProperty),
1078        "UNLOGGED": lambda self: self.expression(exp.UnloggedProperty),
1079        "VOLATILE": lambda self: self._parse_volatile_property(),
1080        "WITH": lambda self: self._parse_with_property(),
1081    }
1082
1083    CONSTRAINT_PARSERS = {
1084        "AUTOINCREMENT": lambda self: self._parse_auto_increment(),
1085        "AUTO_INCREMENT": lambda self: self._parse_auto_increment(),
1086        "CASESPECIFIC": lambda self: self.expression(exp.CaseSpecificColumnConstraint, not_=False),
1087        "CHARACTER SET": lambda self: self.expression(
1088            exp.CharacterSetColumnConstraint, this=self._parse_var_or_string()
1089        ),
1090        "CHECK": lambda self: self.expression(
1091            exp.CheckColumnConstraint,
1092            this=self._parse_wrapped(self._parse_assignment),
1093            enforced=self._match_text_seq("ENFORCED"),
1094        ),
1095        "COLLATE": lambda self: self.expression(
1096            exp.CollateColumnConstraint,
1097            this=self._parse_identifier() or self._parse_column(),
1098        ),
1099        "COMMENT": lambda self: self.expression(
1100            exp.CommentColumnConstraint, this=self._parse_string()
1101        ),
1102        "COMPRESS": lambda self: self._parse_compress(),
1103        "CLUSTERED": lambda self: self.expression(
1104            exp.ClusteredColumnConstraint, this=self._parse_wrapped_csv(self._parse_ordered)
1105        ),
1106        "NONCLUSTERED": lambda self: self.expression(
1107            exp.NonClusteredColumnConstraint, this=self._parse_wrapped_csv(self._parse_ordered)
1108        ),
1109        "DEFAULT": lambda self: self.expression(
1110            exp.DefaultColumnConstraint, this=self._parse_bitwise()
1111        ),
1112        "ENCODE": lambda self: self.expression(exp.EncodeColumnConstraint, this=self._parse_var()),
1113        "EPHEMERAL": lambda self: self.expression(
1114            exp.EphemeralColumnConstraint, this=self._parse_bitwise()
1115        ),
1116        "EXCLUDE": lambda self: self.expression(
1117            exp.ExcludeColumnConstraint, this=self._parse_index_params()
1118        ),
1119        "FOREIGN KEY": lambda self: self._parse_foreign_key(),
1120        "FORMAT": lambda self: self.expression(
1121            exp.DateFormatColumnConstraint, this=self._parse_var_or_string()
1122        ),
1123        "GENERATED": lambda self: self._parse_generated_as_identity(),
1124        "IDENTITY": lambda self: self._parse_auto_increment(),
1125        "INLINE": lambda self: self._parse_inline(),
1126        "LIKE": lambda self: self._parse_create_like(),
1127        "NOT": lambda self: self._parse_not_constraint(),
1128        "NULL": lambda self: self.expression(exp.NotNullColumnConstraint, allow_null=True),
1129        "ON": lambda self: (
1130            self._match(TokenType.UPDATE)
1131            and self.expression(exp.OnUpdateColumnConstraint, this=self._parse_function())
1132        )
1133        or self.expression(exp.OnProperty, this=self._parse_id_var()),
1134        "PATH": lambda self: self.expression(exp.PathColumnConstraint, this=self._parse_string()),
1135        "PERIOD": lambda self: self._parse_period_for_system_time(),
1136        "PRIMARY KEY": lambda self: self._parse_primary_key(),
1137        "REFERENCES": lambda self: self._parse_references(match=False),
1138        "TITLE": lambda self: self.expression(
1139            exp.TitleColumnConstraint, this=self._parse_var_or_string()
1140        ),
1141        "TTL": lambda self: self.expression(exp.MergeTreeTTL, expressions=[self._parse_bitwise()]),
1142        "UNIQUE": lambda self: self._parse_unique(),
1143        "UPPERCASE": lambda self: self.expression(exp.UppercaseColumnConstraint),
1144        "WITH": lambda self: self.expression(
1145            exp.Properties, expressions=self._parse_wrapped_properties()
1146        ),
1147        "BUCKET": lambda self: self._parse_partitioned_by_bucket_or_truncate(),
1148        "TRUNCATE": lambda self: self._parse_partitioned_by_bucket_or_truncate(),
1149    }
1150
1151    def _parse_partitioned_by_bucket_or_truncate(self) -> t.Optional[exp.Expression]:
1152        if not self._match(TokenType.L_PAREN, advance=False):
1153            # Partitioning by bucket or truncate follows the syntax:
1154            # PARTITION BY (BUCKET(..) | TRUNCATE(..))
1155            # If we don't have parenthesis after each keyword, we should instead parse this as an identifier
1156            self._retreat(self._index - 1)
1157            return None
1158
1159        klass = (
1160            exp.PartitionedByBucket
1161            if self._prev.text.upper() == "BUCKET"
1162            else exp.PartitionByTruncate
1163        )
1164
1165        args = self._parse_wrapped_csv(lambda: self._parse_primary() or self._parse_column())
1166        this, expression = seq_get(args, 0), seq_get(args, 1)
1167
1168        if isinstance(this, exp.Literal):
1169            # Check for Iceberg partition transforms (bucket / truncate) and ensure their arguments are in the right order
1170            #  - For Hive, it's `bucket(<num buckets>, <col name>)` or `truncate(<num_chars>, <col_name>)`
1171            #  - For Trino, it's reversed - `bucket(<col name>, <num buckets>)` or `truncate(<col_name>, <num_chars>)`
1172            # Both variants are canonicalized in the latter i.e `bucket(<col name>, <num buckets>)`
1173            #
1174            # Hive ref: https://docs.aws.amazon.com/athena/latest/ug/querying-iceberg-creating-tables.html#querying-iceberg-partitioning
1175            # Trino ref: https://docs.aws.amazon.com/athena/latest/ug/create-table-as.html#ctas-table-properties
1176            this, expression = expression, this
1177
1178        return self.expression(klass, this=this, expression=expression)
1179
1180    ALTER_PARSERS = {
1181        "ADD": lambda self: self._parse_alter_table_add(),
1182        "AS": lambda self: self._parse_select(),
1183        "ALTER": lambda self: self._parse_alter_table_alter(),
1184        "CLUSTER BY": lambda self: self._parse_cluster(wrapped=True),
1185        "DELETE": lambda self: self.expression(exp.Delete, where=self._parse_where()),
1186        "DROP": lambda self: self._parse_alter_table_drop(),
1187        "RENAME": lambda self: self._parse_alter_table_rename(),
1188        "SET": lambda self: self._parse_alter_table_set(),
1189        "SWAP": lambda self: self.expression(
1190            exp.SwapTable, this=self._match(TokenType.WITH) and self._parse_table(schema=True)
1191        ),
1192    }
1193
1194    ALTER_ALTER_PARSERS = {
1195        "DISTKEY": lambda self: self._parse_alter_diststyle(),
1196        "DISTSTYLE": lambda self: self._parse_alter_diststyle(),
1197        "SORTKEY": lambda self: self._parse_alter_sortkey(),
1198        "COMPOUND": lambda self: self._parse_alter_sortkey(compound=True),
1199    }
1200
1201    SCHEMA_UNNAMED_CONSTRAINTS = {
1202        "CHECK",
1203        "EXCLUDE",
1204        "FOREIGN KEY",
1205        "LIKE",
1206        "PERIOD",
1207        "PRIMARY KEY",
1208        "UNIQUE",
1209        "BUCKET",
1210        "TRUNCATE",
1211    }
1212
1213    NO_PAREN_FUNCTION_PARSERS = {
1214        "ANY": lambda self: self.expression(exp.Any, this=self._parse_bitwise()),
1215        "CASE": lambda self: self._parse_case(),
1216        "CONNECT_BY_ROOT": lambda self: self.expression(
1217            exp.ConnectByRoot, this=self._parse_column()
1218        ),
1219        "IF": lambda self: self._parse_if(),
1220    }
1221
1222    INVALID_FUNC_NAME_TOKENS = {
1223        TokenType.IDENTIFIER,
1224        TokenType.STRING,
1225    }
1226
1227    FUNCTIONS_WITH_ALIASED_ARGS = {"STRUCT"}
1228
1229    KEY_VALUE_DEFINITIONS = (exp.Alias, exp.EQ, exp.PropertyEQ, exp.Slice)
1230
1231    FUNCTION_PARSERS = {
1232        **{
1233            name: lambda self: self._parse_max_min_by(exp.ArgMax) for name in exp.ArgMax.sql_names()
1234        },
1235        **{
1236            name: lambda self: self._parse_max_min_by(exp.ArgMin) for name in exp.ArgMin.sql_names()
1237        },
1238        "CAST": lambda self: self._parse_cast(self.STRICT_CAST),
1239        "CEIL": lambda self: self._parse_ceil_floor(exp.Ceil),
1240        "CONVERT": lambda self: self._parse_convert(self.STRICT_CAST),
1241        "DECODE": lambda self: self._parse_decode(),
1242        "EXTRACT": lambda self: self._parse_extract(),
1243        "FLOOR": lambda self: self._parse_ceil_floor(exp.Floor),
1244        "GAP_FILL": lambda self: self._parse_gap_fill(),
1245        "JSON_OBJECT": lambda self: self._parse_json_object(),
1246        "JSON_OBJECTAGG": lambda self: self._parse_json_object(agg=True),
1247        "JSON_TABLE": lambda self: self._parse_json_table(),
1248        "MATCH": lambda self: self._parse_match_against(),
1249        "NORMALIZE": lambda self: self._parse_normalize(),
1250        "OPENJSON": lambda self: self._parse_open_json(),
1251        "OVERLAY": lambda self: self._parse_overlay(),
1252        "POSITION": lambda self: self._parse_position(),
1253        "SAFE_CAST": lambda self: self._parse_cast(False, safe=True),
1254        "STRING_AGG": lambda self: self._parse_string_agg(),
1255        "SUBSTRING": lambda self: self._parse_substring(),
1256        "TRIM": lambda self: self._parse_trim(),
1257        "TRY_CAST": lambda self: self._parse_cast(False, safe=True),
1258        "TRY_CONVERT": lambda self: self._parse_convert(False, safe=True),
1259        "XMLELEMENT": lambda self: self.expression(
1260            exp.XMLElement,
1261            this=self._match_text_seq("NAME") and self._parse_id_var(),
1262            expressions=self._match(TokenType.COMMA) and self._parse_csv(self._parse_expression),
1263        ),
1264        "XMLTABLE": lambda self: self._parse_xml_table(),
1265    }
1266
1267    QUERY_MODIFIER_PARSERS = {
1268        TokenType.MATCH_RECOGNIZE: lambda self: ("match", self._parse_match_recognize()),
1269        TokenType.PREWHERE: lambda self: ("prewhere", self._parse_prewhere()),
1270        TokenType.WHERE: lambda self: ("where", self._parse_where()),
1271        TokenType.GROUP_BY: lambda self: ("group", self._parse_group()),
1272        TokenType.HAVING: lambda self: ("having", self._parse_having()),
1273        TokenType.QUALIFY: lambda self: ("qualify", self._parse_qualify()),
1274        TokenType.WINDOW: lambda self: ("windows", self._parse_window_clause()),
1275        TokenType.ORDER_BY: lambda self: ("order", self._parse_order()),
1276        TokenType.LIMIT: lambda self: ("limit", self._parse_limit()),
1277        TokenType.FETCH: lambda self: ("limit", self._parse_limit()),
1278        TokenType.OFFSET: lambda self: ("offset", self._parse_offset()),
1279        TokenType.FOR: lambda self: ("locks", self._parse_locks()),
1280        TokenType.LOCK: lambda self: ("locks", self._parse_locks()),
1281        TokenType.TABLE_SAMPLE: lambda self: ("sample", self._parse_table_sample(as_modifier=True)),
1282        TokenType.USING: lambda self: ("sample", self._parse_table_sample(as_modifier=True)),
1283        TokenType.CLUSTER_BY: lambda self: (
1284            "cluster",
1285            self._parse_sort(exp.Cluster, TokenType.CLUSTER_BY),
1286        ),
1287        TokenType.DISTRIBUTE_BY: lambda self: (
1288            "distribute",
1289            self._parse_sort(exp.Distribute, TokenType.DISTRIBUTE_BY),
1290        ),
1291        TokenType.SORT_BY: lambda self: ("sort", self._parse_sort(exp.Sort, TokenType.SORT_BY)),
1292        TokenType.CONNECT_BY: lambda self: ("connect", self._parse_connect(skip_start_token=True)),
1293        TokenType.START_WITH: lambda self: ("connect", self._parse_connect()),
1294    }
1295    QUERY_MODIFIER_TOKENS = set(QUERY_MODIFIER_PARSERS)
1296
1297    SET_PARSERS = {
1298        "GLOBAL": lambda self: self._parse_set_item_assignment("GLOBAL"),
1299        "LOCAL": lambda self: self._parse_set_item_assignment("LOCAL"),
1300        "SESSION": lambda self: self._parse_set_item_assignment("SESSION"),
1301        "TRANSACTION": lambda self: self._parse_set_transaction(),
1302    }
1303
1304    SHOW_PARSERS: t.Dict[str, t.Callable] = {}
1305
1306    TYPE_LITERAL_PARSERS = {
1307        exp.DataType.Type.JSON: lambda self, this, _: self.expression(exp.ParseJSON, this=this),
1308    }
1309
1310    TYPE_CONVERTERS: t.Dict[exp.DataType.Type, t.Callable[[exp.DataType], exp.DataType]] = {}
1311
1312    DDL_SELECT_TOKENS = {TokenType.SELECT, TokenType.WITH, TokenType.L_PAREN}
1313
1314    PRE_VOLATILE_TOKENS = {TokenType.CREATE, TokenType.REPLACE, TokenType.UNIQUE}
1315
1316    TRANSACTION_KIND = {"DEFERRED", "IMMEDIATE", "EXCLUSIVE"}
1317    TRANSACTION_CHARACTERISTICS: OPTIONS_TYPE = {
1318        "ISOLATION": (
1319            ("LEVEL", "REPEATABLE", "READ"),
1320            ("LEVEL", "READ", "COMMITTED"),
1321            ("LEVEL", "READ", "UNCOMITTED"),
1322            ("LEVEL", "SERIALIZABLE"),
1323        ),
1324        "READ": ("WRITE", "ONLY"),
1325    }
1326
1327    CONFLICT_ACTIONS: OPTIONS_TYPE = dict.fromkeys(
1328        ("ABORT", "FAIL", "IGNORE", "REPLACE", "ROLLBACK", "UPDATE"), tuple()
1329    )
1330    CONFLICT_ACTIONS["DO"] = ("NOTHING", "UPDATE")
1331
1332    CREATE_SEQUENCE: OPTIONS_TYPE = {
1333        "SCALE": ("EXTEND", "NOEXTEND"),
1334        "SHARD": ("EXTEND", "NOEXTEND"),
1335        "NO": ("CYCLE", "CACHE", "MAXVALUE", "MINVALUE"),
1336        **dict.fromkeys(
1337            (
1338                "SESSION",
1339                "GLOBAL",
1340                "KEEP",
1341                "NOKEEP",
1342                "ORDER",
1343                "NOORDER",
1344                "NOCACHE",
1345                "CYCLE",
1346                "NOCYCLE",
1347                "NOMINVALUE",
1348                "NOMAXVALUE",
1349                "NOSCALE",
1350                "NOSHARD",
1351            ),
1352            tuple(),
1353        ),
1354    }
1355
1356    ISOLATED_LOADING_OPTIONS: OPTIONS_TYPE = {"FOR": ("ALL", "INSERT", "NONE")}
1357
1358    USABLES: OPTIONS_TYPE = dict.fromkeys(
1359        ("ROLE", "WAREHOUSE", "DATABASE", "SCHEMA", "CATALOG"), tuple()
1360    )
1361
1362    CAST_ACTIONS: OPTIONS_TYPE = dict.fromkeys(("RENAME", "ADD"), ("FIELDS",))
1363
1364    SCHEMA_BINDING_OPTIONS: OPTIONS_TYPE = {
1365        "TYPE": ("EVOLUTION",),
1366        **dict.fromkeys(("BINDING", "COMPENSATION", "EVOLUTION"), tuple()),
1367    }
1368
1369    PROCEDURE_OPTIONS: OPTIONS_TYPE = {}
1370
1371    EXECUTE_AS_OPTIONS: OPTIONS_TYPE = dict.fromkeys(("CALLER", "SELF", "OWNER"), tuple())
1372
1373    KEY_CONSTRAINT_OPTIONS: OPTIONS_TYPE = {
1374        "NOT": ("ENFORCED",),
1375        "MATCH": (
1376            "FULL",
1377            "PARTIAL",
1378            "SIMPLE",
1379        ),
1380        "INITIALLY": ("DEFERRED", "IMMEDIATE"),
1381        "USING": (
1382            "BTREE",
1383            "HASH",
1384        ),
1385        **dict.fromkeys(("DEFERRABLE", "NORELY", "RELY"), tuple()),
1386    }
1387
1388    WINDOW_EXCLUDE_OPTIONS: OPTIONS_TYPE = {
1389        "NO": ("OTHERS",),
1390        "CURRENT": ("ROW",),
1391        **dict.fromkeys(("GROUP", "TIES"), tuple()),
1392    }
1393
1394    INSERT_ALTERNATIVES = {"ABORT", "FAIL", "IGNORE", "REPLACE", "ROLLBACK"}
1395
1396    CLONE_KEYWORDS = {"CLONE", "COPY"}
1397    HISTORICAL_DATA_PREFIX = {"AT", "BEFORE", "END"}
1398    HISTORICAL_DATA_KIND = {"OFFSET", "STATEMENT", "STREAM", "TIMESTAMP", "VERSION"}
1399
1400    OPCLASS_FOLLOW_KEYWORDS = {"ASC", "DESC", "NULLS", "WITH"}
1401
1402    OPTYPE_FOLLOW_TOKENS = {TokenType.COMMA, TokenType.R_PAREN}
1403
1404    TABLE_INDEX_HINT_TOKENS = {TokenType.FORCE, TokenType.IGNORE, TokenType.USE}
1405
1406    VIEW_ATTRIBUTES = {"ENCRYPTION", "SCHEMABINDING", "VIEW_METADATA"}
1407
1408    WINDOW_ALIAS_TOKENS = ID_VAR_TOKENS - {TokenType.RANGE, TokenType.ROWS}
1409    WINDOW_BEFORE_PAREN_TOKENS = {TokenType.OVER}
1410    WINDOW_SIDES = {"FOLLOWING", "PRECEDING"}
1411
1412    JSON_KEY_VALUE_SEPARATOR_TOKENS = {TokenType.COLON, TokenType.COMMA, TokenType.IS}
1413
1414    FETCH_TOKENS = ID_VAR_TOKENS - {TokenType.ROW, TokenType.ROWS, TokenType.PERCENT}
1415
1416    ADD_CONSTRAINT_TOKENS = {
1417        TokenType.CONSTRAINT,
1418        TokenType.FOREIGN_KEY,
1419        TokenType.INDEX,
1420        TokenType.KEY,
1421        TokenType.PRIMARY_KEY,
1422        TokenType.UNIQUE,
1423    }
1424
1425    DISTINCT_TOKENS = {TokenType.DISTINCT}
1426
1427    UNNEST_OFFSET_ALIAS_TOKENS = TABLE_ALIAS_TOKENS - SET_OPERATIONS
1428
1429    SELECT_START_TOKENS = {TokenType.L_PAREN, TokenType.WITH, TokenType.SELECT}
1430
1431    COPY_INTO_VARLEN_OPTIONS = {"FILE_FORMAT", "COPY_OPTIONS", "FORMAT_OPTIONS", "CREDENTIAL"}
1432
1433    IS_JSON_PREDICATE_KIND = {"VALUE", "SCALAR", "ARRAY", "OBJECT"}
1434
1435    ODBC_DATETIME_LITERALS = {
1436        "d": exp.Date,
1437        "t": exp.Time,
1438        "ts": exp.Timestamp,
1439    }
1440
1441    ON_CONDITION_TOKENS = {"ERROR", "NULL", "TRUE", "FALSE", "EMPTY"}
1442
1443    PRIVILEGE_FOLLOW_TOKENS = {TokenType.ON, TokenType.COMMA, TokenType.L_PAREN}
1444
1445    # The style options for the DESCRIBE statement
1446    DESCRIBE_STYLES = {"ANALYZE", "EXTENDED", "FORMATTED", "HISTORY"}
1447
1448    # The style options for the ANALYZE statement
1449    ANALYZE_STYLES = {
1450        "BUFFER_USAGE_LIMIT",
1451        "FULL",
1452        "LOCAL",
1453        "NO_WRITE_TO_BINLOG",
1454        "SAMPLE",
1455        "SKIP_LOCKED",
1456        "VERBOSE",
1457    }
1458
1459    ANALYZE_EXPRESSION_PARSERS = {
1460        "ALL": lambda self: self._parse_analyze_columns(),
1461        "COMPUTE": lambda self: self._parse_analyze_statistics(),
1462        "DELETE": lambda self: self._parse_analyze_delete(),
1463        "DROP": lambda self: self._parse_analyze_histogram(),
1464        "ESTIMATE": lambda self: self._parse_analyze_statistics(),
1465        "LIST": lambda self: self._parse_analyze_list(),
1466        "PREDICATE": lambda self: self._parse_analyze_columns(),
1467        "UPDATE": lambda self: self._parse_analyze_histogram(),
1468        "VALIDATE": lambda self: self._parse_analyze_validate(),
1469    }
1470
1471    PARTITION_KEYWORDS = {"PARTITION", "SUBPARTITION"}
1472
1473    AMBIGUOUS_ALIAS_TOKENS = (TokenType.LIMIT, TokenType.OFFSET)
1474
1475    OPERATION_MODIFIERS: t.Set[str] = set()
1476
1477    RECURSIVE_CTE_SEARCH_KIND = {"BREADTH", "DEPTH", "CYCLE"}
1478
1479    MODIFIABLES = (exp.Query, exp.Table, exp.TableFromRows)
1480
1481    STRICT_CAST = True
1482
1483    PREFIXED_PIVOT_COLUMNS = False
1484    IDENTIFY_PIVOT_STRINGS = False
1485
1486    LOG_DEFAULTS_TO_LN = False
1487
1488    # Whether the table sample clause expects CSV syntax
1489    TABLESAMPLE_CSV = False
1490
1491    # The default method used for table sampling
1492    DEFAULT_SAMPLING_METHOD: t.Optional[str] = None
1493
1494    # Whether the SET command needs a delimiter (e.g. "=") for assignments
1495    SET_REQUIRES_ASSIGNMENT_DELIMITER = True
1496
1497    # Whether the TRIM function expects the characters to trim as its first argument
1498    TRIM_PATTERN_FIRST = False
1499
1500    # Whether string aliases are supported `SELECT COUNT(*) 'count'`
1501    STRING_ALIASES = False
1502
1503    # Whether query modifiers such as LIMIT are attached to the UNION node (vs its right operand)
1504    MODIFIERS_ATTACHED_TO_SET_OP = True
1505    SET_OP_MODIFIERS = {"order", "limit", "offset"}
1506
1507    # Whether to parse IF statements that aren't followed by a left parenthesis as commands
1508    NO_PAREN_IF_COMMANDS = True
1509
1510    # Whether the -> and ->> operators expect documents of type JSON (e.g. Postgres)
1511    JSON_ARROWS_REQUIRE_JSON_TYPE = False
1512
1513    # Whether the `:` operator is used to extract a value from a VARIANT column
1514    COLON_IS_VARIANT_EXTRACT = False
1515
1516    # Whether or not a VALUES keyword needs to be followed by '(' to form a VALUES clause.
1517    # If this is True and '(' is not found, the keyword will be treated as an identifier
1518    VALUES_FOLLOWED_BY_PAREN = True
1519
1520    # Whether implicit unnesting is supported, e.g. SELECT 1 FROM y.z AS z, z.a (Redshift)
1521    SUPPORTS_IMPLICIT_UNNEST = False
1522
1523    # Whether or not interval spans are supported, INTERVAL 1 YEAR TO MONTHS
1524    INTERVAL_SPANS = True
1525
1526    # Whether a PARTITION clause can follow a table reference
1527    SUPPORTS_PARTITION_SELECTION = False
1528
1529    # Whether the `name AS expr` schema/column constraint requires parentheses around `expr`
1530    WRAPPED_TRANSFORM_COLUMN_CONSTRAINT = True
1531
1532    # Whether the 'AS' keyword is optional in the CTE definition syntax
1533    OPTIONAL_ALIAS_TOKEN_CTE = True
1534
1535    # Whether renaming a column with an ALTER statement requires the presence of the COLUMN keyword
1536    ALTER_RENAME_REQUIRES_COLUMN = True
1537
1538    # Whether all join types have the same precedence, i.e., they "naturally" produce a left-deep tree.
1539    # In standard SQL, joins that use the JOIN keyword take higher precedence than comma-joins. That is
1540    # to say, JOIN operators happen before comma operators. This is not the case in some dialects, such
1541    # as BigQuery, where all joins have the same precedence.
1542    JOINS_HAVE_EQUAL_PRECEDENCE = False
1543
1544    # Whether TIMESTAMP <literal> can produce a zone-aware timestamp
1545    ZONE_AWARE_TIMESTAMP_CONSTRUCTOR = False
1546
1547    # Whether map literals support arbitrary expressions as keys.
1548    # When True, allows complex keys like arrays or literals: {[1, 2]: 3}, {1: 2} (e.g. DuckDB).
1549    # When False, keys are typically restricted to identifiers.
1550    MAP_KEYS_ARE_ARBITRARY_EXPRESSIONS = False
1551
1552    # Whether JSON_EXTRACT requires a JSON expression as the first argument, e.g this
1553    # is true for Snowflake but not for BigQuery which can also process strings
1554    JSON_EXTRACT_REQUIRES_JSON_EXPRESSION = False
1555
1556    # Dialects like Databricks support JOINS without join criteria
1557    # Adding an ON TRUE, makes transpilation semantically correct for other dialects
1558    ADD_JOIN_ON_TRUE = False
1559
1560    # Whether INTERVAL spans with literal format '\d+ hh:[mm:[ss[.ff]]]'
1561    # can omit the span unit `DAY TO MINUTE` or `DAY TO SECOND`
1562    SUPPORTS_OMITTED_INTERVAL_SPAN_UNIT = False
1563
1564    __slots__ = (
1565        "error_level",
1566        "error_message_context",
1567        "max_errors",
1568        "dialect",
1569        "sql",
1570        "errors",
1571        "_tokens",
1572        "_index",
1573        "_curr",
1574        "_next",
1575        "_prev",
1576        "_prev_comments",
1577        "_pipe_cte_counter",
1578    )
1579
1580    # Autofilled
1581    SHOW_TRIE: t.Dict = {}
1582    SET_TRIE: t.Dict = {}
1583
1584    def __init__(
1585        self,
1586        error_level: t.Optional[ErrorLevel] = None,
1587        error_message_context: int = 100,
1588        max_errors: int = 3,
1589        dialect: DialectType = None,
1590    ):
1591        from sqlglot.dialects import Dialect
1592
1593        self.error_level = error_level or ErrorLevel.IMMEDIATE
1594        self.error_message_context = error_message_context
1595        self.max_errors = max_errors
1596        self.dialect = Dialect.get_or_raise(dialect)
1597        self.reset()
1598
1599    def reset(self):
1600        self.sql = ""
1601        self.errors = []
1602        self._tokens = []
1603        self._index = 0
1604        self._curr = None
1605        self._next = None
1606        self._prev = None
1607        self._prev_comments = None
1608        self._pipe_cte_counter = 0
1609
1610    def parse(
1611        self, raw_tokens: t.List[Token], sql: t.Optional[str] = None
1612    ) -> t.List[t.Optional[exp.Expression]]:
1613        """
1614        Parses a list of tokens and returns a list of syntax trees, one tree
1615        per parsed SQL statement.
1616
1617        Args:
1618            raw_tokens: The list of tokens.
1619            sql: The original SQL string, used to produce helpful debug messages.
1620
1621        Returns:
1622            The list of the produced syntax trees.
1623        """
1624        return self._parse(
1625            parse_method=self.__class__._parse_statement, raw_tokens=raw_tokens, sql=sql
1626        )
1627
1628    def parse_into(
1629        self,
1630        expression_types: exp.IntoType,
1631        raw_tokens: t.List[Token],
1632        sql: t.Optional[str] = None,
1633    ) -> t.List[t.Optional[exp.Expression]]:
1634        """
1635        Parses a list of tokens into a given Expression type. If a collection of Expression
1636        types is given instead, this method will try to parse the token list into each one
1637        of them, stopping at the first for which the parsing succeeds.
1638
1639        Args:
1640            expression_types: The expression type(s) to try and parse the token list into.
1641            raw_tokens: The list of tokens.
1642            sql: The original SQL string, used to produce helpful debug messages.
1643
1644        Returns:
1645            The target Expression.
1646        """
1647        errors = []
1648        for expression_type in ensure_list(expression_types):
1649            parser = self.EXPRESSION_PARSERS.get(expression_type)
1650            if not parser:
1651                raise TypeError(f"No parser registered for {expression_type}")
1652
1653            try:
1654                return self._parse(parser, raw_tokens, sql)
1655            except ParseError as e:
1656                e.errors[0]["into_expression"] = expression_type
1657                errors.append(e)
1658
1659        raise ParseError(
1660            f"Failed to parse '{sql or raw_tokens}' into {expression_types}",
1661            errors=merge_errors(errors),
1662        ) from errors[-1]
1663
1664    def _parse(
1665        self,
1666        parse_method: t.Callable[[Parser], t.Optional[exp.Expression]],
1667        raw_tokens: t.List[Token],
1668        sql: t.Optional[str] = None,
1669    ) -> t.List[t.Optional[exp.Expression]]:
1670        self.reset()
1671        self.sql = sql or ""
1672
1673        total = len(raw_tokens)
1674        chunks: t.List[t.List[Token]] = [[]]
1675
1676        for i, token in enumerate(raw_tokens):
1677            if token.token_type == TokenType.SEMICOLON:
1678                if token.comments:
1679                    chunks.append([token])
1680
1681                if i < total - 1:
1682                    chunks.append([])
1683            else:
1684                chunks[-1].append(token)
1685
1686        expressions = []
1687
1688        for tokens in chunks:
1689            self._index = -1
1690            self._tokens = tokens
1691            self._advance()
1692
1693            expressions.append(parse_method(self))
1694
1695            if self._index < len(self._tokens):
1696                self.raise_error("Invalid expression / Unexpected token")
1697
1698            self.check_errors()
1699
1700        return expressions
1701
1702    def check_errors(self) -> None:
1703        """Logs or raises any found errors, depending on the chosen error level setting."""
1704        if self.error_level == ErrorLevel.WARN:
1705            for error in self.errors:
1706                logger.error(str(error))
1707        elif self.error_level == ErrorLevel.RAISE and self.errors:
1708            raise ParseError(
1709                concat_messages(self.errors, self.max_errors),
1710                errors=merge_errors(self.errors),
1711            )
1712
1713    def raise_error(self, message: str, token: t.Optional[Token] = None) -> None:
1714        """
1715        Appends an error in the list of recorded errors or raises it, depending on the chosen
1716        error level setting.
1717        """
1718        token = token or self._curr or self._prev or Token.string("")
1719        start = token.start
1720        end = token.end + 1
1721        start_context = self.sql[max(start - self.error_message_context, 0) : start]
1722        highlight = self.sql[start:end]
1723        end_context = self.sql[end : end + self.error_message_context]
1724
1725        error = ParseError.new(
1726            f"{message}. Line {token.line}, Col: {token.col}.\n"
1727            f"  {start_context}\033[4m{highlight}\033[0m{end_context}",
1728            description=message,
1729            line=token.line,
1730            col=token.col,
1731            start_context=start_context,
1732            highlight=highlight,
1733            end_context=end_context,
1734        )
1735
1736        if self.error_level == ErrorLevel.IMMEDIATE:
1737            raise error
1738
1739        self.errors.append(error)
1740
1741    def expression(
1742        self, exp_class: t.Type[E], comments: t.Optional[t.List[str]] = None, **kwargs
1743    ) -> E:
1744        """
1745        Creates a new, validated Expression.
1746
1747        Args:
1748            exp_class: The expression class to instantiate.
1749            comments: An optional list of comments to attach to the expression.
1750            kwargs: The arguments to set for the expression along with their respective values.
1751
1752        Returns:
1753            The target expression.
1754        """
1755        instance = exp_class(**kwargs)
1756        instance.add_comments(comments) if comments else self._add_comments(instance)
1757        return self.validate_expression(instance)
1758
1759    def _add_comments(self, expression: t.Optional[exp.Expression]) -> None:
1760        if expression and self._prev_comments:
1761            expression.add_comments(self._prev_comments)
1762            self._prev_comments = None
1763
1764    def validate_expression(self, expression: E, args: t.Optional[t.List] = None) -> E:
1765        """
1766        Validates an Expression, making sure that all its mandatory arguments are set.
1767
1768        Args:
1769            expression: The expression to validate.
1770            args: An optional list of items that was used to instantiate the expression, if it's a Func.
1771
1772        Returns:
1773            The validated expression.
1774        """
1775        if self.error_level != ErrorLevel.IGNORE:
1776            for error_message in expression.error_messages(args):
1777                self.raise_error(error_message)
1778
1779        return expression
1780
1781    def _find_sql(self, start: Token, end: Token) -> str:
1782        return self.sql[start.start : end.end + 1]
1783
1784    def _is_connected(self) -> bool:
1785        return self._prev and self._curr and self._prev.end + 1 == self._curr.start
1786
1787    def _advance(self, times: int = 1) -> None:
1788        self._index += times
1789        self._curr = seq_get(self._tokens, self._index)
1790        self._next = seq_get(self._tokens, self._index + 1)
1791
1792        if self._index > 0:
1793            self._prev = self._tokens[self._index - 1]
1794            self._prev_comments = self._prev.comments
1795        else:
1796            self._prev = None
1797            self._prev_comments = None
1798
1799    def _retreat(self, index: int) -> None:
1800        if index != self._index:
1801            self._advance(index - self._index)
1802
1803    def _warn_unsupported(self) -> None:
1804        if len(self._tokens) <= 1:
1805            return
1806
1807        # We use _find_sql because self.sql may comprise multiple chunks, and we're only
1808        # interested in emitting a warning for the one being currently processed.
1809        sql = self._find_sql(self._tokens[0], self._tokens[-1])[: self.error_message_context]
1810
1811        logger.warning(
1812            f"'{sql}' contains unsupported syntax. Falling back to parsing as a 'Command'."
1813        )
1814
1815    def _parse_command(self) -> exp.Command:
1816        self._warn_unsupported()
1817        return self.expression(
1818            exp.Command,
1819            comments=self._prev_comments,
1820            this=self._prev.text.upper(),
1821            expression=self._parse_string(),
1822        )
1823
1824    def _try_parse(self, parse_method: t.Callable[[], T], retreat: bool = False) -> t.Optional[T]:
1825        """
1826        Attemps to backtrack if a parse function that contains a try/catch internally raises an error.
1827        This behavior can be different depending on the uset-set ErrorLevel, so _try_parse aims to
1828        solve this by setting & resetting the parser state accordingly
1829        """
1830        index = self._index
1831        error_level = self.error_level
1832
1833        self.error_level = ErrorLevel.IMMEDIATE
1834        try:
1835            this = parse_method()
1836        except ParseError:
1837            this = None
1838        finally:
1839            if not this or retreat:
1840                self._retreat(index)
1841            self.error_level = error_level
1842
1843        return this
1844
1845    def _parse_comment(self, allow_exists: bool = True) -> exp.Expression:
1846        start = self._prev
1847        exists = self._parse_exists() if allow_exists else None
1848
1849        self._match(TokenType.ON)
1850
1851        materialized = self._match_text_seq("MATERIALIZED")
1852        kind = self._match_set(self.CREATABLES) and self._prev
1853        if not kind:
1854            return self._parse_as_command(start)
1855
1856        if kind.token_type in (TokenType.FUNCTION, TokenType.PROCEDURE):
1857            this = self._parse_user_defined_function(kind=kind.token_type)
1858        elif kind.token_type == TokenType.TABLE:
1859            this = self._parse_table(alias_tokens=self.COMMENT_TABLE_ALIAS_TOKENS)
1860        elif kind.token_type == TokenType.COLUMN:
1861            this = self._parse_column()
1862        else:
1863            this = self._parse_id_var()
1864
1865        self._match(TokenType.IS)
1866
1867        return self.expression(
1868            exp.Comment,
1869            this=this,
1870            kind=kind.text,
1871            expression=self._parse_string(),
1872            exists=exists,
1873            materialized=materialized,
1874        )
1875
1876    def _parse_to_table(
1877        self,
1878    ) -> exp.ToTableProperty:
1879        table = self._parse_table_parts(schema=True)
1880        return self.expression(exp.ToTableProperty, this=table)
1881
1882    # https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/mergetree#mergetree-table-ttl
1883    def _parse_ttl(self) -> exp.Expression:
1884        def _parse_ttl_action() -> t.Optional[exp.Expression]:
1885            this = self._parse_bitwise()
1886
1887            if self._match_text_seq("DELETE"):
1888                return self.expression(exp.MergeTreeTTLAction, this=this, delete=True)
1889            if self._match_text_seq("RECOMPRESS"):
1890                return self.expression(
1891                    exp.MergeTreeTTLAction, this=this, recompress=self._parse_bitwise()
1892                )
1893            if self._match_text_seq("TO", "DISK"):
1894                return self.expression(
1895                    exp.MergeTreeTTLAction, this=this, to_disk=self._parse_string()
1896                )
1897            if self._match_text_seq("TO", "VOLUME"):
1898                return self.expression(
1899                    exp.MergeTreeTTLAction, this=this, to_volume=self._parse_string()
1900                )
1901
1902            return this
1903
1904        expressions = self._parse_csv(_parse_ttl_action)
1905        where = self._parse_where()
1906        group = self._parse_group()
1907
1908        aggregates = None
1909        if group and self._match(TokenType.SET):
1910            aggregates = self._parse_csv(self._parse_set_item)
1911
1912        return self.expression(
1913            exp.MergeTreeTTL,
1914            expressions=expressions,
1915            where=where,
1916            group=group,
1917            aggregates=aggregates,
1918        )
1919
1920    def _parse_statement(self) -> t.Optional[exp.Expression]:
1921        if self._curr is None:
1922            return None
1923
1924        if self._match_set(self.STATEMENT_PARSERS):
1925            comments = self._prev_comments
1926            stmt = self.STATEMENT_PARSERS[self._prev.token_type](self)
1927            stmt.add_comments(comments, prepend=True)
1928            return stmt
1929
1930        if self._match_set(self.dialect.tokenizer_class.COMMANDS):
1931            return self._parse_command()
1932
1933        expression = self._parse_expression()
1934        expression = self._parse_set_operations(expression) if expression else self._parse_select()
1935        return self._parse_query_modifiers(expression)
1936
1937    def _parse_drop(self, exists: bool = False) -> exp.Drop | exp.Command:
1938        start = self._prev
1939        temporary = self._match(TokenType.TEMPORARY)
1940        materialized = self._match_text_seq("MATERIALIZED")
1941
1942        kind = self._match_set(self.CREATABLES) and self._prev.text.upper()
1943        if not kind:
1944            return self._parse_as_command(start)
1945
1946        concurrently = self._match_text_seq("CONCURRENTLY")
1947        if_exists = exists or self._parse_exists()
1948
1949        if kind == "COLUMN":
1950            this = self._parse_column()
1951        else:
1952            this = self._parse_table_parts(
1953                schema=True, is_db_reference=self._prev.token_type == TokenType.SCHEMA
1954            )
1955
1956        cluster = self._parse_on_property() if self._match(TokenType.ON) else None
1957
1958        if self._match(TokenType.L_PAREN, advance=False):
1959            expressions = self._parse_wrapped_csv(self._parse_types)
1960        else:
1961            expressions = None
1962
1963        return self.expression(
1964            exp.Drop,
1965            exists=if_exists,
1966            this=this,
1967            expressions=expressions,
1968            kind=self.dialect.CREATABLE_KIND_MAPPING.get(kind) or kind,
1969            temporary=temporary,
1970            materialized=materialized,
1971            cascade=self._match_text_seq("CASCADE"),
1972            constraints=self._match_text_seq("CONSTRAINTS"),
1973            purge=self._match_text_seq("PURGE"),
1974            cluster=cluster,
1975            concurrently=concurrently,
1976        )
1977
1978    def _parse_exists(self, not_: bool = False) -> t.Optional[bool]:
1979        return (
1980            self._match_text_seq("IF")
1981            and (not not_ or self._match(TokenType.NOT))
1982            and self._match(TokenType.EXISTS)
1983        )
1984
1985    def _parse_create(self) -> exp.Create | exp.Command:
1986        # Note: this can't be None because we've matched a statement parser
1987        start = self._prev
1988
1989        replace = (
1990            start.token_type == TokenType.REPLACE
1991            or self._match_pair(TokenType.OR, TokenType.REPLACE)
1992            or self._match_pair(TokenType.OR, TokenType.ALTER)
1993        )
1994        refresh = self._match_pair(TokenType.OR, TokenType.REFRESH)
1995
1996        unique = self._match(TokenType.UNIQUE)
1997
1998        if self._match_text_seq("CLUSTERED", "COLUMNSTORE"):
1999            clustered = True
2000        elif self._match_text_seq("NONCLUSTERED", "COLUMNSTORE") or self._match_text_seq(
2001            "COLUMNSTORE"
2002        ):
2003            clustered = False
2004        else:
2005            clustered = None
2006
2007        if self._match_pair(TokenType.TABLE, TokenType.FUNCTION, advance=False):
2008            self._advance()
2009
2010        properties = None
2011        create_token = self._match_set(self.CREATABLES) and self._prev
2012
2013        if not create_token:
2014            # exp.Properties.Location.POST_CREATE
2015            properties = self._parse_properties()
2016            create_token = self._match_set(self.CREATABLES) and self._prev
2017
2018            if not properties or not create_token:
2019                return self._parse_as_command(start)
2020
2021        concurrently = self._match_text_seq("CONCURRENTLY")
2022        exists = self._parse_exists(not_=True)
2023        this = None
2024        expression: t.Optional[exp.Expression] = None
2025        indexes = None
2026        no_schema_binding = None
2027        begin = None
2028        end = None
2029        clone = None
2030
2031        def extend_props(temp_props: t.Optional[exp.Properties]) -> None:
2032            nonlocal properties
2033            if properties and temp_props:
2034                properties.expressions.extend(temp_props.expressions)
2035            elif temp_props:
2036                properties = temp_props
2037
2038        if create_token.token_type in (TokenType.FUNCTION, TokenType.PROCEDURE):
2039            this = self._parse_user_defined_function(kind=create_token.token_type)
2040
2041            # exp.Properties.Location.POST_SCHEMA ("schema" here is the UDF's type signature)
2042            extend_props(self._parse_properties())
2043
2044            expression = self._match(TokenType.ALIAS) and self._parse_heredoc()
2045            extend_props(self._parse_properties())
2046
2047            if not expression:
2048                if self._match(TokenType.COMMAND):
2049                    expression = self._parse_as_command(self._prev)
2050                else:
2051                    begin = self._match(TokenType.BEGIN)
2052                    return_ = self._match_text_seq("RETURN")
2053
2054                    if self._match(TokenType.STRING, advance=False):
2055                        # Takes care of BigQuery's JavaScript UDF definitions that end in an OPTIONS property
2056                        # # https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_function_statement
2057                        expression = self._parse_string()
2058                        extend_props(self._parse_properties())
2059                    else:
2060                        expression = self._parse_user_defined_function_expression()
2061
2062                    end = self._match_text_seq("END")
2063
2064                    if return_:
2065                        expression = self.expression(exp.Return, this=expression)
2066        elif create_token.token_type == TokenType.INDEX:
2067            # Postgres allows anonymous indexes, eg. CREATE INDEX IF NOT EXISTS ON t(c)
2068            if not self._match(TokenType.ON):
2069                index = self._parse_id_var()
2070                anonymous = False
2071            else:
2072                index = None
2073                anonymous = True
2074
2075            this = self._parse_index(index=index, anonymous=anonymous)
2076        elif create_token.token_type in self.DB_CREATABLES:
2077            table_parts = self._parse_table_parts(
2078                schema=True, is_db_reference=create_token.token_type == TokenType.SCHEMA
2079            )
2080
2081            # exp.Properties.Location.POST_NAME
2082            self._match(TokenType.COMMA)
2083            extend_props(self._parse_properties(before=True))
2084
2085            this = self._parse_schema(this=table_parts)
2086
2087            # exp.Properties.Location.POST_SCHEMA and POST_WITH
2088            extend_props(self._parse_properties())
2089
2090            has_alias = self._match(TokenType.ALIAS)
2091            if not self._match_set(self.DDL_SELECT_TOKENS, advance=False):
2092                # exp.Properties.Location.POST_ALIAS
2093                extend_props(self._parse_properties())
2094
2095            if create_token.token_type == TokenType.SEQUENCE:
2096                expression = self._parse_types()
2097                props = self._parse_properties()
2098                if props:
2099                    sequence_props = exp.SequenceProperties()
2100                    options = []
2101                    for prop in props:
2102                        if isinstance(prop, exp.SequenceProperties):
2103                            for arg, value in prop.args.items():
2104                                if arg == "options":
2105                                    options.extend(value)
2106                                else:
2107                                    sequence_props.set(arg, value)
2108                            prop.pop()
2109
2110                    if options:
2111                        sequence_props.set("options", options)
2112
2113                    props.append("expressions", sequence_props)
2114                    extend_props(props)
2115            else:
2116                expression = self._parse_ddl_select()
2117
2118                # Some dialects also support using a table as an alias instead of a SELECT.
2119                # Here we fallback to this as an alternative.
2120                if not expression and has_alias:
2121                    expression = self._try_parse(self._parse_table_parts)
2122
2123            if create_token.token_type == TokenType.TABLE:
2124                # exp.Properties.Location.POST_EXPRESSION
2125                extend_props(self._parse_properties())
2126
2127                indexes = []
2128                while True:
2129                    index = self._parse_index()
2130
2131                    # exp.Properties.Location.POST_INDEX
2132                    extend_props(self._parse_properties())
2133                    if not index:
2134                        break
2135                    else:
2136                        self._match(TokenType.COMMA)
2137                        indexes.append(index)
2138            elif create_token.token_type == TokenType.VIEW:
2139                if self._match_text_seq("WITH", "NO", "SCHEMA", "BINDING"):
2140                    no_schema_binding = True
2141            elif create_token.token_type in (TokenType.SINK, TokenType.SOURCE):
2142                extend_props(self._parse_properties())
2143
2144            shallow = self._match_text_seq("SHALLOW")
2145
2146            if self._match_texts(self.CLONE_KEYWORDS):
2147                copy = self._prev.text.lower() == "copy"
2148                clone = self.expression(
2149                    exp.Clone, this=self._parse_table(schema=True), shallow=shallow, copy=copy
2150                )
2151
2152        if self._curr and not self._match_set((TokenType.R_PAREN, TokenType.COMMA), advance=False):
2153            return self._parse_as_command(start)
2154
2155        create_kind_text = create_token.text.upper()
2156        return self.expression(
2157            exp.Create,
2158            this=this,
2159            kind=self.dialect.CREATABLE_KIND_MAPPING.get(create_kind_text) or create_kind_text,
2160            replace=replace,
2161            refresh=refresh,
2162            unique=unique,
2163            expression=expression,
2164            exists=exists,
2165            properties=properties,
2166            indexes=indexes,
2167            no_schema_binding=no_schema_binding,
2168            begin=begin,
2169            end=end,
2170            clone=clone,
2171            concurrently=concurrently,
2172            clustered=clustered,
2173        )
2174
2175    def _parse_sequence_properties(self) -> t.Optional[exp.SequenceProperties]:
2176        seq = exp.SequenceProperties()
2177
2178        options = []
2179        index = self._index
2180
2181        while self._curr:
2182            self._match(TokenType.COMMA)
2183            if self._match_text_seq("INCREMENT"):
2184                self._match_text_seq("BY")
2185                self._match_text_seq("=")
2186                seq.set("increment", self._parse_term())
2187            elif self._match_text_seq("MINVALUE"):
2188                seq.set("minvalue", self._parse_term())
2189            elif self._match_text_seq("MAXVALUE"):
2190                seq.set("maxvalue", self._parse_term())
2191            elif self._match(TokenType.START_WITH) or self._match_text_seq("START"):
2192                self._match_text_seq("=")
2193                seq.set("start", self._parse_term())
2194            elif self._match_text_seq("CACHE"):
2195                # T-SQL allows empty CACHE which is initialized dynamically
2196                seq.set("cache", self._parse_number() or True)
2197            elif self._match_text_seq("OWNED", "BY"):
2198                # "OWNED BY NONE" is the default
2199                seq.set("owned", None if self._match_text_seq("NONE") else self._parse_column())
2200            else:
2201                opt = self._parse_var_from_options(self.CREATE_SEQUENCE, raise_unmatched=False)
2202                if opt:
2203                    options.append(opt)
2204                else:
2205                    break
2206
2207        seq.set("options", options if options else None)
2208        return None if self._index == index else seq
2209
2210    def _parse_property_before(self) -> t.Optional[exp.Expression]:
2211        # only used for teradata currently
2212        self._match(TokenType.COMMA)
2213
2214        kwargs = {
2215            "no": self._match_text_seq("NO"),
2216            "dual": self._match_text_seq("DUAL"),
2217            "before": self._match_text_seq("BEFORE"),
2218            "default": self._match_text_seq("DEFAULT"),
2219            "local": (self._match_text_seq("LOCAL") and "LOCAL")
2220            or (self._match_text_seq("NOT", "LOCAL") and "NOT LOCAL"),
2221            "after": self._match_text_seq("AFTER"),
2222            "minimum": self._match_texts(("MIN", "MINIMUM")),
2223            "maximum": self._match_texts(("MAX", "MAXIMUM")),
2224        }
2225
2226        if self._match_texts(self.PROPERTY_PARSERS):
2227            parser = self.PROPERTY_PARSERS[self._prev.text.upper()]
2228            try:
2229                return parser(self, **{k: v for k, v in kwargs.items() if v})
2230            except TypeError:
2231                self.raise_error(f"Cannot parse property '{self._prev.text}'")
2232
2233        return None
2234
2235    def _parse_wrapped_properties(self) -> t.List[exp.Expression]:
2236        return self._parse_wrapped_csv(self._parse_property)
2237
2238    def _parse_property(self) -> t.Optional[exp.Expression]:
2239        if self._match_texts(self.PROPERTY_PARSERS):
2240            return self.PROPERTY_PARSERS[self._prev.text.upper()](self)
2241
2242        if self._match(TokenType.DEFAULT) and self._match_texts(self.PROPERTY_PARSERS):
2243            return self.PROPERTY_PARSERS[self._prev.text.upper()](self, default=True)
2244
2245        if self._match_text_seq("COMPOUND", "SORTKEY"):
2246            return self._parse_sortkey(compound=True)
2247
2248        if self._match_text_seq("SQL", "SECURITY"):
2249            return self.expression(exp.SqlSecurityProperty, definer=self._match_text_seq("DEFINER"))
2250
2251        index = self._index
2252
2253        seq_props = self._parse_sequence_properties()
2254        if seq_props:
2255            return seq_props
2256
2257        self._retreat(index)
2258        key = self._parse_column()
2259
2260        if not self._match(TokenType.EQ):
2261            self._retreat(index)
2262            return None
2263
2264        # Transform the key to exp.Dot if it's dotted identifiers wrapped in exp.Column or to exp.Var otherwise
2265        if isinstance(key, exp.Column):
2266            key = key.to_dot() if len(key.parts) > 1 else exp.var(key.name)
2267
2268        value = self._parse_bitwise() or self._parse_var(any_token=True)
2269
2270        # Transform the value to exp.Var if it was parsed as exp.Column(exp.Identifier())
2271        if isinstance(value, exp.Column):
2272            value = exp.var(value.name)
2273
2274        return self.expression(exp.Property, this=key, value=value)
2275
2276    def _parse_stored(self) -> t.Union[exp.FileFormatProperty, exp.StorageHandlerProperty]:
2277        if self._match_text_seq("BY"):
2278            return self.expression(exp.StorageHandlerProperty, this=self._parse_var_or_string())
2279
2280        self._match(TokenType.ALIAS)
2281        input_format = self._parse_string() if self._match_text_seq("INPUTFORMAT") else None
2282        output_format = self._parse_string() if self._match_text_seq("OUTPUTFORMAT") else None
2283
2284        return self.expression(
2285            exp.FileFormatProperty,
2286            this=(
2287                self.expression(
2288                    exp.InputOutputFormat,
2289                    input_format=input_format,
2290                    output_format=output_format,
2291                )
2292                if input_format or output_format
2293                else self._parse_var_or_string() or self._parse_number() or self._parse_id_var()
2294            ),
2295            hive_format=True,
2296        )
2297
2298    def _parse_unquoted_field(self) -> t.Optional[exp.Expression]:
2299        field = self._parse_field()
2300        if isinstance(field, exp.Identifier) and not field.quoted:
2301            field = exp.var(field)
2302
2303        return field
2304
2305    def _parse_property_assignment(self, exp_class: t.Type[E], **kwargs: t.Any) -> E:
2306        self._match(TokenType.EQ)
2307        self._match(TokenType.ALIAS)
2308
2309        return self.expression(exp_class, this=self._parse_unquoted_field(), **kwargs)
2310
2311    def _parse_properties(self, before: t.Optional[bool] = None) -> t.Optional[exp.Properties]:
2312        properties = []
2313        while True:
2314            if before:
2315                prop = self._parse_property_before()
2316            else:
2317                prop = self._parse_property()
2318            if not prop:
2319                break
2320            for p in ensure_list(prop):
2321                properties.append(p)
2322
2323        if properties:
2324            return self.expression(exp.Properties, expressions=properties)
2325
2326        return None
2327
2328    def _parse_fallback(self, no: bool = False) -> exp.FallbackProperty:
2329        return self.expression(
2330            exp.FallbackProperty, no=no, protection=self._match_text_seq("PROTECTION")
2331        )
2332
2333    def _parse_security(self) -> t.Optional[exp.SecurityProperty]:
2334        if self._match_texts(("NONE", "DEFINER", "INVOKER")):
2335            security_specifier = self._prev.text.upper()
2336            return self.expression(exp.SecurityProperty, this=security_specifier)
2337        return None
2338
2339    def _parse_settings_property(self) -> exp.SettingsProperty:
2340        return self.expression(
2341            exp.SettingsProperty, expressions=self._parse_csv(self._parse_assignment)
2342        )
2343
2344    def _parse_volatile_property(self) -> exp.VolatileProperty | exp.StabilityProperty:
2345        if self._index >= 2:
2346            pre_volatile_token = self._tokens[self._index - 2]
2347        else:
2348            pre_volatile_token = None
2349
2350        if pre_volatile_token and pre_volatile_token.token_type in self.PRE_VOLATILE_TOKENS:
2351            return exp.VolatileProperty()
2352
2353        return self.expression(exp.StabilityProperty, this=exp.Literal.string("VOLATILE"))
2354
2355    def _parse_retention_period(self) -> exp.Var:
2356        # Parse TSQL's HISTORY_RETENTION_PERIOD: {INFINITE | <number> DAY | DAYS | MONTH ...}
2357        number = self._parse_number()
2358        number_str = f"{number} " if number else ""
2359        unit = self._parse_var(any_token=True)
2360        return exp.var(f"{number_str}{unit}")
2361
2362    def _parse_system_versioning_property(
2363        self, with_: bool = False
2364    ) -> exp.WithSystemVersioningProperty:
2365        self._match(TokenType.EQ)
2366        prop = self.expression(
2367            exp.WithSystemVersioningProperty,
2368            **{  # type: ignore
2369                "on": True,
2370                "with": with_,
2371            },
2372        )
2373
2374        if self._match_text_seq("OFF"):
2375            prop.set("on", False)
2376            return prop
2377
2378        self._match(TokenType.ON)
2379        if self._match(TokenType.L_PAREN):
2380            while self._curr and not self._match(TokenType.R_PAREN):
2381                if self._match_text_seq("HISTORY_TABLE", "="):
2382                    prop.set("this", self._parse_table_parts())
2383                elif self._match_text_seq("DATA_CONSISTENCY_CHECK", "="):
2384                    prop.set("data_consistency", self._advance_any() and self._prev.text.upper())
2385                elif self._match_text_seq("HISTORY_RETENTION_PERIOD", "="):
2386                    prop.set("retention_period", self._parse_retention_period())
2387
2388                self._match(TokenType.COMMA)
2389
2390        return prop
2391
2392    def _parse_data_deletion_property(self) -> exp.DataDeletionProperty:
2393        self._match(TokenType.EQ)
2394        on = self._match_text_seq("ON") or not self._match_text_seq("OFF")
2395        prop = self.expression(exp.DataDeletionProperty, on=on)
2396
2397        if self._match(TokenType.L_PAREN):
2398            while self._curr and not self._match(TokenType.R_PAREN):
2399                if self._match_text_seq("FILTER_COLUMN", "="):
2400                    prop.set("filter_column", self._parse_column())
2401                elif self._match_text_seq("RETENTION_PERIOD", "="):
2402                    prop.set("retention_period", self._parse_retention_period())
2403
2404                self._match(TokenType.COMMA)
2405
2406        return prop
2407
2408    def _parse_distributed_property(self) -> exp.DistributedByProperty:
2409        kind = "HASH"
2410        expressions: t.Optional[t.List[exp.Expression]] = None
2411        if self._match_text_seq("BY", "HASH"):
2412            expressions = self._parse_wrapped_csv(self._parse_id_var)
2413        elif self._match_text_seq("BY", "RANDOM"):
2414            kind = "RANDOM"
2415
2416        # If the BUCKETS keyword is not present, the number of buckets is AUTO
2417        buckets: t.Optional[exp.Expression] = None
2418        if self._match_text_seq("BUCKETS") and not self._match_text_seq("AUTO"):
2419            buckets = self._parse_number()
2420
2421        return self.expression(
2422            exp.DistributedByProperty,
2423            expressions=expressions,
2424            kind=kind,
2425            buckets=buckets,
2426            order=self._parse_order(),
2427        )
2428
2429    def _parse_composite_key_property(self, expr_type: t.Type[E]) -> E:
2430        self._match_text_seq("KEY")
2431        expressions = self._parse_wrapped_id_vars()
2432        return self.expression(expr_type, expressions=expressions)
2433
2434    def _parse_with_property(self) -> t.Optional[exp.Expression] | t.List[exp.Expression]:
2435        if self._match_text_seq("(", "SYSTEM_VERSIONING"):
2436            prop = self._parse_system_versioning_property(with_=True)
2437            self._match_r_paren()
2438            return prop
2439
2440        if self._match(TokenType.L_PAREN, advance=False):
2441            return self._parse_wrapped_properties()
2442
2443        if self._match_text_seq("JOURNAL"):
2444            return self._parse_withjournaltable()
2445
2446        if self._match_texts(self.VIEW_ATTRIBUTES):
2447            return self.expression(exp.ViewAttributeProperty, this=self._prev.text.upper())
2448
2449        if self._match_text_seq("DATA"):
2450            return self._parse_withdata(no=False)
2451        elif self._match_text_seq("NO", "DATA"):
2452            return self._parse_withdata(no=True)
2453
2454        if self._match(TokenType.SERDE_PROPERTIES, advance=False):
2455            return self._parse_serde_properties(with_=True)
2456
2457        if self._match(TokenType.SCHEMA):
2458            return self.expression(
2459                exp.WithSchemaBindingProperty,
2460                this=self._parse_var_from_options(self.SCHEMA_BINDING_OPTIONS),
2461            )
2462
2463        if self._match_texts(self.PROCEDURE_OPTIONS, advance=False):
2464            return self.expression(
2465                exp.WithProcedureOptions, expressions=self._parse_csv(self._parse_procedure_option)
2466            )
2467
2468        if not self._next:
2469            return None
2470
2471        return self._parse_withisolatedloading()
2472
2473    def _parse_procedure_option(self) -> exp.Expression | None:
2474        if self._match_text_seq("EXECUTE", "AS"):
2475            return self.expression(
2476                exp.ExecuteAsProperty,
2477                this=self._parse_var_from_options(self.EXECUTE_AS_OPTIONS, raise_unmatched=False)
2478                or self._parse_string(),
2479            )
2480
2481        return self._parse_var_from_options(self.PROCEDURE_OPTIONS)
2482
2483    # https://dev.mysql.com/doc/refman/8.0/en/create-view.html
2484    def _parse_definer(self) -> t.Optional[exp.DefinerProperty]:
2485        self._match(TokenType.EQ)
2486
2487        user = self._parse_id_var()
2488        self._match(TokenType.PARAMETER)
2489        host = self._parse_id_var() or (self._match(TokenType.MOD) and self._prev.text)
2490
2491        if not user or not host:
2492            return None
2493
2494        return exp.DefinerProperty(this=f"{user}@{host}")
2495
2496    def _parse_withjournaltable(self) -> exp.WithJournalTableProperty:
2497        self._match(TokenType.TABLE)
2498        self._match(TokenType.EQ)
2499        return self.expression(exp.WithJournalTableProperty, this=self._parse_table_parts())
2500
2501    def _parse_log(self, no: bool = False) -> exp.LogProperty:
2502        return self.expression(exp.LogProperty, no=no)
2503
2504    def _parse_journal(self, **kwargs) -> exp.JournalProperty:
2505        return self.expression(exp.JournalProperty, **kwargs)
2506
2507    def _parse_checksum(self) -> exp.ChecksumProperty:
2508        self._match(TokenType.EQ)
2509
2510        on = None
2511        if self._match(TokenType.ON):
2512            on = True
2513        elif self._match_text_seq("OFF"):
2514            on = False
2515
2516        return self.expression(exp.ChecksumProperty, on=on, default=self._match(TokenType.DEFAULT))
2517
2518    def _parse_cluster(self, wrapped: bool = False) -> exp.Cluster:
2519        return self.expression(
2520            exp.Cluster,
2521            expressions=(
2522                self._parse_wrapped_csv(self._parse_ordered)
2523                if wrapped
2524                else self._parse_csv(self._parse_ordered)
2525            ),
2526        )
2527
2528    def _parse_clustered_by(self) -> exp.ClusteredByProperty:
2529        self._match_text_seq("BY")
2530
2531        self._match_l_paren()
2532        expressions = self._parse_csv(self._parse_column)
2533        self._match_r_paren()
2534
2535        if self._match_text_seq("SORTED", "BY"):
2536            self._match_l_paren()
2537            sorted_by = self._parse_csv(self._parse_ordered)
2538            self._match_r_paren()
2539        else:
2540            sorted_by = None
2541
2542        self._match(TokenType.INTO)
2543        buckets = self._parse_number()
2544        self._match_text_seq("BUCKETS")
2545
2546        return self.expression(
2547            exp.ClusteredByProperty,
2548            expressions=expressions,
2549            sorted_by=sorted_by,
2550            buckets=buckets,
2551        )
2552
2553    def _parse_copy_property(self) -> t.Optional[exp.CopyGrantsProperty]:
2554        if not self._match_text_seq("GRANTS"):
2555            self._retreat(self._index - 1)
2556            return None
2557
2558        return self.expression(exp.CopyGrantsProperty)
2559
2560    def _parse_freespace(self) -> exp.FreespaceProperty:
2561        self._match(TokenType.EQ)
2562        return self.expression(
2563            exp.FreespaceProperty, this=self._parse_number(), percent=self._match(TokenType.PERCENT)
2564        )
2565
2566    def _parse_mergeblockratio(
2567        self, no: bool = False, default: bool = False
2568    ) -> exp.MergeBlockRatioProperty:
2569        if self._match(TokenType.EQ):
2570            return self.expression(
2571                exp.MergeBlockRatioProperty,
2572                this=self._parse_number(),
2573                percent=self._match(TokenType.PERCENT),
2574            )
2575
2576        return self.expression(exp.MergeBlockRatioProperty, no=no, default=default)
2577
2578    def _parse_datablocksize(
2579        self,
2580        default: t.Optional[bool] = None,
2581        minimum: t.Optional[bool] = None,
2582        maximum: t.Optional[bool] = None,
2583    ) -> exp.DataBlocksizeProperty:
2584        self._match(TokenType.EQ)
2585        size = self._parse_number()
2586
2587        units = None
2588        if self._match_texts(("BYTES", "KBYTES", "KILOBYTES")):
2589            units = self._prev.text
2590
2591        return self.expression(
2592            exp.DataBlocksizeProperty,
2593            size=size,
2594            units=units,
2595            default=default,
2596            minimum=minimum,
2597            maximum=maximum,
2598        )
2599
2600    def _parse_blockcompression(self) -> exp.BlockCompressionProperty:
2601        self._match(TokenType.EQ)
2602        always = self._match_text_seq("ALWAYS")
2603        manual = self._match_text_seq("MANUAL")
2604        never = self._match_text_seq("NEVER")
2605        default = self._match_text_seq("DEFAULT")
2606
2607        autotemp = None
2608        if self._match_text_seq("AUTOTEMP"):
2609            autotemp = self._parse_schema()
2610
2611        return self.expression(
2612            exp.BlockCompressionProperty,
2613            always=always,
2614            manual=manual,
2615            never=never,
2616            default=default,
2617            autotemp=autotemp,
2618        )
2619
2620    def _parse_withisolatedloading(self) -> t.Optional[exp.IsolatedLoadingProperty]:
2621        index = self._index
2622        no = self._match_text_seq("NO")
2623        concurrent = self._match_text_seq("CONCURRENT")
2624
2625        if not self._match_text_seq("ISOLATED", "LOADING"):
2626            self._retreat(index)
2627            return None
2628
2629        target = self._parse_var_from_options(self.ISOLATED_LOADING_OPTIONS, raise_unmatched=False)
2630        return self.expression(
2631            exp.IsolatedLoadingProperty, no=no, concurrent=concurrent, target=target
2632        )
2633
2634    def _parse_locking(self) -> exp.LockingProperty:
2635        if self._match(TokenType.TABLE):
2636            kind = "TABLE"
2637        elif self._match(TokenType.VIEW):
2638            kind = "VIEW"
2639        elif self._match(TokenType.ROW):
2640            kind = "ROW"
2641        elif self._match_text_seq("DATABASE"):
2642            kind = "DATABASE"
2643        else:
2644            kind = None
2645
2646        if kind in ("DATABASE", "TABLE", "VIEW"):
2647            this = self._parse_table_parts()
2648        else:
2649            this = None
2650
2651        if self._match(TokenType.FOR):
2652            for_or_in = "FOR"
2653        elif self._match(TokenType.IN):
2654            for_or_in = "IN"
2655        else:
2656            for_or_in = None
2657
2658        if self._match_text_seq("ACCESS"):
2659            lock_type = "ACCESS"
2660        elif self._match_texts(("EXCL", "EXCLUSIVE")):
2661            lock_type = "EXCLUSIVE"
2662        elif self._match_text_seq("SHARE"):
2663            lock_type = "SHARE"
2664        elif self._match_text_seq("READ"):
2665            lock_type = "READ"
2666        elif self._match_text_seq("WRITE"):
2667            lock_type = "WRITE"
2668        elif self._match_text_seq("CHECKSUM"):
2669            lock_type = "CHECKSUM"
2670        else:
2671            lock_type = None
2672
2673        override = self._match_text_seq("OVERRIDE")
2674
2675        return self.expression(
2676            exp.LockingProperty,
2677            this=this,
2678            kind=kind,
2679            for_or_in=for_or_in,
2680            lock_type=lock_type,
2681            override=override,
2682        )
2683
2684    def _parse_partition_by(self) -> t.List[exp.Expression]:
2685        if self._match(TokenType.PARTITION_BY):
2686            return self._parse_csv(self._parse_assignment)
2687        return []
2688
2689    def _parse_partition_bound_spec(self) -> exp.PartitionBoundSpec:
2690        def _parse_partition_bound_expr() -> t.Optional[exp.Expression]:
2691            if self._match_text_seq("MINVALUE"):
2692                return exp.var("MINVALUE")
2693            if self._match_text_seq("MAXVALUE"):
2694                return exp.var("MAXVALUE")
2695            return self._parse_bitwise()
2696
2697        this: t.Optional[exp.Expression | t.List[exp.Expression]] = None
2698        expression = None
2699        from_expressions = None
2700        to_expressions = None
2701
2702        if self._match(TokenType.IN):
2703            this = self._parse_wrapped_csv(self._parse_bitwise)
2704        elif self._match(TokenType.FROM):
2705            from_expressions = self._parse_wrapped_csv(_parse_partition_bound_expr)
2706            self._match_text_seq("TO")
2707            to_expressions = self._parse_wrapped_csv(_parse_partition_bound_expr)
2708        elif self._match_text_seq("WITH", "(", "MODULUS"):
2709            this = self._parse_number()
2710            self._match_text_seq(",", "REMAINDER")
2711            expression = self._parse_number()
2712            self._match_r_paren()
2713        else:
2714            self.raise_error("Failed to parse partition bound spec.")
2715
2716        return self.expression(
2717            exp.PartitionBoundSpec,
2718            this=this,
2719            expression=expression,
2720            from_expressions=from_expressions,
2721            to_expressions=to_expressions,
2722        )
2723
2724    # https://www.postgresql.org/docs/current/sql-createtable.html
2725    def _parse_partitioned_of(self) -> t.Optional[exp.PartitionedOfProperty]:
2726        if not self._match_text_seq("OF"):
2727            self._retreat(self._index - 1)
2728            return None
2729
2730        this = self._parse_table(schema=True)
2731
2732        if self._match(TokenType.DEFAULT):
2733            expression: exp.Var | exp.PartitionBoundSpec = exp.var("DEFAULT")
2734        elif self._match_text_seq("FOR", "VALUES"):
2735            expression = self._parse_partition_bound_spec()
2736        else:
2737            self.raise_error("Expecting either DEFAULT or FOR VALUES clause.")
2738
2739        return self.expression(exp.PartitionedOfProperty, this=this, expression=expression)
2740
2741    def _parse_partitioned_by(self) -> exp.PartitionedByProperty:
2742        self._match(TokenType.EQ)
2743        return self.expression(
2744            exp.PartitionedByProperty,
2745            this=self._parse_schema() or self._parse_bracket(self._parse_field()),
2746        )
2747
2748    def _parse_withdata(self, no: bool = False) -> exp.WithDataProperty:
2749        if self._match_text_seq("AND", "STATISTICS"):
2750            statistics = True
2751        elif self._match_text_seq("AND", "NO", "STATISTICS"):
2752            statistics = False
2753        else:
2754            statistics = None
2755
2756        return self.expression(exp.WithDataProperty, no=no, statistics=statistics)
2757
2758    def _parse_contains_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
2759        if self._match_text_seq("SQL"):
2760            return self.expression(exp.SqlReadWriteProperty, this="CONTAINS SQL")
2761        return None
2762
2763    def _parse_modifies_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
2764        if self._match_text_seq("SQL", "DATA"):
2765            return self.expression(exp.SqlReadWriteProperty, this="MODIFIES SQL DATA")
2766        return None
2767
2768    def _parse_no_property(self) -> t.Optional[exp.Expression]:
2769        if self._match_text_seq("PRIMARY", "INDEX"):
2770            return exp.NoPrimaryIndexProperty()
2771        if self._match_text_seq("SQL"):
2772            return self.expression(exp.SqlReadWriteProperty, this="NO SQL")
2773        return None
2774
2775    def _parse_on_property(self) -> t.Optional[exp.Expression]:
2776        if self._match_text_seq("COMMIT", "PRESERVE", "ROWS"):
2777            return exp.OnCommitProperty()
2778        if self._match_text_seq("COMMIT", "DELETE", "ROWS"):
2779            return exp.OnCommitProperty(delete=True)
2780        return self.expression(exp.OnProperty, this=self._parse_schema(self._parse_id_var()))
2781
2782    def _parse_reads_property(self) -> t.Optional[exp.SqlReadWriteProperty]:
2783        if self._match_text_seq("SQL", "DATA"):
2784            return self.expression(exp.SqlReadWriteProperty, this="READS SQL DATA")
2785        return None
2786
2787    def _parse_distkey(self) -> exp.DistKeyProperty:
2788        return self.expression(exp.DistKeyProperty, this=self._parse_wrapped(self._parse_id_var))
2789
2790    def _parse_create_like(self) -> t.Optional[exp.LikeProperty]:
2791        table = self._parse_table(schema=True)
2792
2793        options = []
2794        while self._match_texts(("INCLUDING", "EXCLUDING")):
2795            this = self._prev.text.upper()
2796
2797            id_var = self._parse_id_var()
2798            if not id_var:
2799                return None
2800
2801            options.append(
2802                self.expression(exp.Property, this=this, value=exp.var(id_var.this.upper()))
2803            )
2804
2805        return self.expression(exp.LikeProperty, this=table, expressions=options)
2806
2807    def _parse_sortkey(self, compound: bool = False) -> exp.SortKeyProperty:
2808        return self.expression(
2809            exp.SortKeyProperty, this=self._parse_wrapped_id_vars(), compound=compound
2810        )
2811
2812    def _parse_character_set(self, default: bool = False) -> exp.CharacterSetProperty:
2813        self._match(TokenType.EQ)
2814        return self.expression(
2815            exp.CharacterSetProperty, this=self._parse_var_or_string(), default=default
2816        )
2817
2818    def _parse_remote_with_connection(self) -> exp.RemoteWithConnectionModelProperty:
2819        self._match_text_seq("WITH", "CONNECTION")
2820        return self.expression(
2821            exp.RemoteWithConnectionModelProperty, this=self._parse_table_parts()
2822        )
2823
2824    def _parse_returns(self) -> exp.ReturnsProperty:
2825        value: t.Optional[exp.Expression]
2826        null = None
2827        is_table = self._match(TokenType.TABLE)
2828
2829        if is_table:
2830            if self._match(TokenType.LT):
2831                value = self.expression(
2832                    exp.Schema,
2833                    this="TABLE",
2834                    expressions=self._parse_csv(self._parse_struct_types),
2835                )
2836                if not self._match(TokenType.GT):
2837                    self.raise_error("Expecting >")
2838            else:
2839                value = self._parse_schema(exp.var("TABLE"))
2840        elif self._match_text_seq("NULL", "ON", "NULL", "INPUT"):
2841            null = True
2842            value = None
2843        else:
2844            value = self._parse_types()
2845
2846        return self.expression(exp.ReturnsProperty, this=value, is_table=is_table, null=null)
2847
2848    def _parse_describe(self) -> exp.Describe:
2849        kind = self._match_set(self.CREATABLES) and self._prev.text
2850        style = self._match_texts(self.DESCRIBE_STYLES) and self._prev.text.upper()
2851        if self._match(TokenType.DOT):
2852            style = None
2853            self._retreat(self._index - 2)
2854
2855        format = self._parse_property() if self._match(TokenType.FORMAT, advance=False) else None
2856
2857        if self._match_set(self.STATEMENT_PARSERS, advance=False):
2858            this = self._parse_statement()
2859        else:
2860            this = self._parse_table(schema=True)
2861
2862        properties = self._parse_properties()
2863        expressions = properties.expressions if properties else None
2864        partition = self._parse_partition()
2865        return self.expression(
2866            exp.Describe,
2867            this=this,
2868            style=style,
2869            kind=kind,
2870            expressions=expressions,
2871            partition=partition,
2872            format=format,
2873        )
2874
2875    def _parse_multitable_inserts(self, comments: t.Optional[t.List[str]]) -> exp.MultitableInserts:
2876        kind = self._prev.text.upper()
2877        expressions = []
2878
2879        def parse_conditional_insert() -> t.Optional[exp.ConditionalInsert]:
2880            if self._match(TokenType.WHEN):
2881                expression = self._parse_disjunction()
2882                self._match(TokenType.THEN)
2883            else:
2884                expression = None
2885
2886            else_ = self._match(TokenType.ELSE)
2887
2888            if not self._match(TokenType.INTO):
2889                return None
2890
2891            return self.expression(
2892                exp.ConditionalInsert,
2893                this=self.expression(
2894                    exp.Insert,
2895                    this=self._parse_table(schema=True),
2896                    expression=self._parse_derived_table_values(),
2897                ),
2898                expression=expression,
2899                else_=else_,
2900            )
2901
2902        expression = parse_conditional_insert()
2903        while expression is not None:
2904            expressions.append(expression)
2905            expression = parse_conditional_insert()
2906
2907        return self.expression(
2908            exp.MultitableInserts,
2909            kind=kind,
2910            comments=comments,
2911            expressions=expressions,
2912            source=self._parse_table(),
2913        )
2914
2915    def _parse_insert(self) -> t.Union[exp.Insert, exp.MultitableInserts]:
2916        comments = []
2917        hint = self._parse_hint()
2918        overwrite = self._match(TokenType.OVERWRITE)
2919        ignore = self._match(TokenType.IGNORE)
2920        local = self._match_text_seq("LOCAL")
2921        alternative = None
2922        is_function = None
2923
2924        if self._match_text_seq("DIRECTORY"):
2925            this: t.Optional[exp.Expression] = self.expression(
2926                exp.Directory,
2927                this=self._parse_var_or_string(),
2928                local=local,
2929                row_format=self._parse_row_format(match_row=True),
2930            )
2931        else:
2932            if self._match_set((TokenType.FIRST, TokenType.ALL)):
2933                comments += ensure_list(self._prev_comments)
2934                return self._parse_multitable_inserts(comments)
2935
2936            if self._match(TokenType.OR):
2937                alternative = self._match_texts(self.INSERT_ALTERNATIVES) and self._prev.text
2938
2939            self._match(TokenType.INTO)
2940            comments += ensure_list(self._prev_comments)
2941            self._match(TokenType.TABLE)
2942            is_function = self._match(TokenType.FUNCTION)
2943
2944            this = (
2945                self._parse_table(schema=True, parse_partition=True)
2946                if not is_function
2947                else self._parse_function()
2948            )
2949            if isinstance(this, exp.Table) and self._match(TokenType.ALIAS, advance=False):
2950                this.set("alias", self._parse_table_alias())
2951
2952        returning = self._parse_returning()
2953
2954        return self.expression(
2955            exp.Insert,
2956            comments=comments,
2957            hint=hint,
2958            is_function=is_function,
2959            this=this,
2960            stored=self._match_text_seq("STORED") and self._parse_stored(),
2961            by_name=self._match_text_seq("BY", "NAME"),
2962            exists=self._parse_exists(),
2963            where=self._match_pair(TokenType.REPLACE, TokenType.WHERE) and self._parse_assignment(),
2964            partition=self._match(TokenType.PARTITION_BY) and self._parse_partitioned_by(),
2965            settings=self._match_text_seq("SETTINGS") and self._parse_settings_property(),
2966            expression=self._parse_derived_table_values() or self._parse_ddl_select(),
2967            conflict=self._parse_on_conflict(),
2968            returning=returning or self._parse_returning(),
2969            overwrite=overwrite,
2970            alternative=alternative,
2971            ignore=ignore,
2972            source=self._match(TokenType.TABLE) and self._parse_table(),
2973        )
2974
2975    def _parse_kill(self) -> exp.Kill:
2976        kind = exp.var(self._prev.text) if self._match_texts(("CONNECTION", "QUERY")) else None
2977
2978        return self.expression(
2979            exp.Kill,
2980            this=self._parse_primary(),
2981            kind=kind,
2982        )
2983
2984    def _parse_on_conflict(self) -> t.Optional[exp.OnConflict]:
2985        conflict = self._match_text_seq("ON", "CONFLICT")
2986        duplicate = self._match_text_seq("ON", "DUPLICATE", "KEY")
2987
2988        if not conflict and not duplicate:
2989            return None
2990
2991        conflict_keys = None
2992        constraint = None
2993
2994        if conflict:
2995            if self._match_text_seq("ON", "CONSTRAINT"):
2996                constraint = self._parse_id_var()
2997            elif self._match(TokenType.L_PAREN):
2998                conflict_keys = self._parse_csv(self._parse_id_var)
2999                self._match_r_paren()
3000
3001        action = self._parse_var_from_options(self.CONFLICT_ACTIONS)
3002        if self._prev.token_type == TokenType.UPDATE:
3003            self._match(TokenType.SET)
3004            expressions = self._parse_csv(self._parse_equality)
3005        else:
3006            expressions = None
3007
3008        return self.expression(
3009            exp.OnConflict,
3010            duplicate=duplicate,
3011            expressions=expressions,
3012            action=action,
3013            conflict_keys=conflict_keys,
3014            constraint=constraint,
3015            where=self._parse_where(),
3016        )
3017
3018    def _parse_returning(self) -> t.Optional[exp.Returning]:
3019        if not self._match(TokenType.RETURNING):
3020            return None
3021        return self.expression(
3022            exp.Returning,
3023            expressions=self._parse_csv(self._parse_expression),
3024            into=self._match(TokenType.INTO) and self._parse_table_part(),
3025        )
3026
3027    def _parse_row(self) -> t.Optional[exp.RowFormatSerdeProperty | exp.RowFormatDelimitedProperty]:
3028        if not self._match(TokenType.FORMAT):
3029            return None
3030        return self._parse_row_format()
3031
3032    def _parse_serde_properties(self, with_: bool = False) -> t.Optional[exp.SerdeProperties]:
3033        index = self._index
3034        with_ = with_ or self._match_text_seq("WITH")
3035
3036        if not self._match(TokenType.SERDE_PROPERTIES):
3037            self._retreat(index)
3038            return None
3039        return self.expression(
3040            exp.SerdeProperties,
3041            **{  # type: ignore
3042                "expressions": self._parse_wrapped_properties(),
3043                "with": with_,
3044            },
3045        )
3046
3047    def _parse_row_format(
3048        self, match_row: bool = False
3049    ) -> t.Optional[exp.RowFormatSerdeProperty | exp.RowFormatDelimitedProperty]:
3050        if match_row and not self._match_pair(TokenType.ROW, TokenType.FORMAT):
3051            return None
3052
3053        if self._match_text_seq("SERDE"):
3054            this = self._parse_string()
3055
3056            serde_properties = self._parse_serde_properties()
3057
3058            return self.expression(
3059                exp.RowFormatSerdeProperty, this=this, serde_properties=serde_properties
3060            )
3061
3062        self._match_text_seq("DELIMITED")
3063
3064        kwargs = {}
3065
3066        if self._match_text_seq("FIELDS", "TERMINATED", "BY"):
3067            kwargs["fields"] = self._parse_string()
3068            if self._match_text_seq("ESCAPED", "BY"):
3069                kwargs["escaped"] = self._parse_string()
3070        if self._match_text_seq("COLLECTION", "ITEMS", "TERMINATED", "BY"):
3071            kwargs["collection_items"] = self._parse_string()
3072        if self._match_text_seq("MAP", "KEYS", "TERMINATED", "BY"):
3073            kwargs["map_keys"] = self._parse_string()
3074        if self._match_text_seq("LINES", "TERMINATED", "BY"):
3075            kwargs["lines"] = self._parse_string()
3076        if self._match_text_seq("NULL", "DEFINED", "AS"):
3077            kwargs["null"] = self._parse_string()
3078
3079        return self.expression(exp.RowFormatDelimitedProperty, **kwargs)  # type: ignore
3080
3081    def _parse_load(self) -> exp.LoadData | exp.Command:
3082        if self._match_text_seq("DATA"):
3083            local = self._match_text_seq("LOCAL")
3084            self._match_text_seq("INPATH")
3085            inpath = self._parse_string()
3086            overwrite = self._match(TokenType.OVERWRITE)
3087            self._match_pair(TokenType.INTO, TokenType.TABLE)
3088
3089            return self.expression(
3090                exp.LoadData,
3091                this=self._parse_table(schema=True),
3092                local=local,
3093                overwrite=overwrite,
3094                inpath=inpath,
3095                partition=self._parse_partition(),
3096                input_format=self._match_text_seq("INPUTFORMAT") and self._parse_string(),
3097                serde=self._match_text_seq("SERDE") and self._parse_string(),
3098            )
3099        return self._parse_as_command(self._prev)
3100
3101    def _parse_delete(self) -> exp.Delete:
3102        # This handles MySQL's "Multiple-Table Syntax"
3103        # https://dev.mysql.com/doc/refman/8.0/en/delete.html
3104        tables = None
3105        if not self._match(TokenType.FROM, advance=False):
3106            tables = self._parse_csv(self._parse_table) or None
3107
3108        returning = self._parse_returning()
3109
3110        return self.expression(
3111            exp.Delete,
3112            tables=tables,
3113            this=self._match(TokenType.FROM) and self._parse_table(joins=True),
3114            using=self._match(TokenType.USING) and self._parse_table(joins=True),
3115            cluster=self._match(TokenType.ON) and self._parse_on_property(),
3116            where=self._parse_where(),
3117            returning=returning or self._parse_returning(),
3118            limit=self._parse_limit(),
3119        )
3120
3121    def _parse_update(self) -> exp.Update:
3122        kwargs: t.Dict[str, t.Any] = {
3123            "this": self._parse_table(joins=True, alias_tokens=self.UPDATE_ALIAS_TOKENS),
3124        }
3125        while self._curr:
3126            if self._match(TokenType.SET):
3127                kwargs["expressions"] = self._parse_csv(self._parse_equality)
3128            elif self._match(TokenType.RETURNING, advance=False):
3129                kwargs["returning"] = self._parse_returning()
3130            elif self._match(TokenType.FROM, advance=False):
3131                kwargs["from"] = self._parse_from(joins=True)
3132            elif self._match(TokenType.WHERE, advance=False):
3133                kwargs["where"] = self._parse_where()
3134            elif self._match(TokenType.ORDER_BY, advance=False):
3135                kwargs["order"] = self._parse_order()
3136            elif self._match(TokenType.LIMIT, advance=False):
3137                kwargs["limit"] = self._parse_limit()
3138            else:
3139                break
3140
3141        return self.expression(exp.Update, **kwargs)
3142
3143    def _parse_use(self) -> exp.Use:
3144        return self.expression(
3145            exp.Use,
3146            kind=self._parse_var_from_options(self.USABLES, raise_unmatched=False),
3147            this=self._parse_table(schema=False),
3148        )
3149
3150    def _parse_uncache(self) -> exp.Uncache:
3151        if not self._match(TokenType.TABLE):
3152            self.raise_error("Expecting TABLE after UNCACHE")
3153
3154        return self.expression(
3155            exp.Uncache, exists=self._parse_exists(), this=self._parse_table(schema=True)
3156        )
3157
3158    def _parse_cache(self) -> exp.Cache:
3159        lazy = self._match_text_seq("LAZY")
3160        self._match(TokenType.TABLE)
3161        table = self._parse_table(schema=True)
3162
3163        options = []
3164        if self._match_text_seq("OPTIONS"):
3165            self._match_l_paren()
3166            k = self._parse_string()
3167            self._match(TokenType.EQ)
3168            v = self._parse_string()
3169            options = [k, v]
3170            self._match_r_paren()
3171
3172        self._match(TokenType.ALIAS)
3173        return self.expression(
3174            exp.Cache,
3175            this=table,
3176            lazy=lazy,
3177            options=options,
3178            expression=self._parse_select(nested=True),
3179        )
3180
3181    def _parse_partition(self) -> t.Optional[exp.Partition]:
3182        if not self._match_texts(self.PARTITION_KEYWORDS):
3183            return None
3184
3185        return self.expression(
3186            exp.Partition,
3187            subpartition=self._prev.text.upper() == "SUBPARTITION",
3188            expressions=self._parse_wrapped_csv(self._parse_assignment),
3189        )
3190
3191    def _parse_value(self, values: bool = True) -> t.Optional[exp.Tuple]:
3192        def _parse_value_expression() -> t.Optional[exp.Expression]:
3193            if self.dialect.SUPPORTS_VALUES_DEFAULT and self._match(TokenType.DEFAULT):
3194                return exp.var(self._prev.text.upper())
3195            return self._parse_expression()
3196
3197        if self._match(TokenType.L_PAREN):
3198            expressions = self._parse_csv(_parse_value_expression)
3199            self._match_r_paren()
3200            return self.expression(exp.Tuple, expressions=expressions)
3201
3202        # In some dialects we can have VALUES 1, 2 which results in 1 column & 2 rows.
3203        expression = self._parse_expression()
3204        if expression:
3205            return self.expression(exp.Tuple, expressions=[expression])
3206        return None
3207
3208    def _parse_projections(self) -> t.List[exp.Expression]:
3209        return self._parse_expressions()
3210
3211    def _parse_wrapped_select(self, table: bool = False) -> t.Optional[exp.Expression]:
3212        if self._match_set((TokenType.PIVOT, TokenType.UNPIVOT)):
3213            this: t.Optional[exp.Expression] = self._parse_simplified_pivot(
3214                is_unpivot=self._prev.token_type == TokenType.UNPIVOT
3215            )
3216        elif self._match(TokenType.FROM):
3217            from_ = self._parse_from(skip_from_token=True, consume_pipe=True)
3218            # Support parentheses for duckdb FROM-first syntax
3219            select = self._parse_select(from_=from_)
3220            if select:
3221                if not select.args.get("from"):
3222                    select.set("from", from_)
3223                this = select
3224            else:
3225                this = exp.select("*").from_(t.cast(exp.From, from_))
3226        else:
3227            this = (
3228                self._parse_table(consume_pipe=True)
3229                if table
3230                else self._parse_select(nested=True, parse_set_operation=False)
3231            )
3232
3233            # Transform exp.Values into a exp.Table to pass through parse_query_modifiers
3234            # in case a modifier (e.g. join) is following
3235            if table and isinstance(this, exp.Values) and this.alias:
3236                alias = this.args["alias"].pop()
3237                this = exp.Table(this=this, alias=alias)
3238
3239            this = self._parse_query_modifiers(self._parse_set_operations(this))
3240
3241        return this
3242
3243    def _parse_select(
3244        self,
3245        nested: bool = False,
3246        table: bool = False,
3247        parse_subquery_alias: bool = True,
3248        parse_set_operation: bool = True,
3249        consume_pipe: bool = True,
3250        from_: t.Optional[exp.From] = None,
3251    ) -> t.Optional[exp.Expression]:
3252        query = self._parse_select_query(
3253            nested=nested,
3254            table=table,
3255            parse_subquery_alias=parse_subquery_alias,
3256            parse_set_operation=parse_set_operation,
3257        )
3258
3259        if consume_pipe and self._match(TokenType.PIPE_GT, advance=False):
3260            if not query and from_:
3261                query = exp.select("*").from_(from_)
3262            if isinstance(query, exp.Query):
3263                query = self._parse_pipe_syntax_query(query)
3264                query = query.subquery(copy=False) if query and table else query
3265
3266        return query
3267
3268    def _parse_select_query(
3269        self,
3270        nested: bool = False,
3271        table: bool = False,
3272        parse_subquery_alias: bool = True,
3273        parse_set_operation: bool = True,
3274    ) -> t.Optional[exp.Expression]:
3275        cte = self._parse_with()
3276
3277        if cte:
3278            this = self._parse_statement()
3279
3280            if not this:
3281                self.raise_error("Failed to parse any statement following CTE")
3282                return cte
3283
3284            if "with" in this.arg_types:
3285                this.set("with", cte)
3286            else:
3287                self.raise_error(f"{this.key} does not support CTE")
3288                this = cte
3289
3290            return this
3291
3292        # duckdb supports leading with FROM x
3293        from_ = (
3294            self._parse_from(consume_pipe=True)
3295            if self._match(TokenType.FROM, advance=False)
3296            else None
3297        )
3298
3299        if self._match(TokenType.SELECT):
3300            comments = self._prev_comments
3301
3302            hint = self._parse_hint()
3303
3304            if self._next and not self._next.token_type == TokenType.DOT:
3305                all_ = self._match(TokenType.ALL)
3306                distinct = self._match_set(self.DISTINCT_TOKENS)
3307            else:
3308                all_, distinct = None, None
3309
3310            kind = (
3311                self._match(TokenType.ALIAS)
3312                and self._match_texts(("STRUCT", "VALUE"))
3313                and self._prev.text.upper()
3314            )
3315
3316            if distinct:
3317                distinct = self.expression(
3318                    exp.Distinct,
3319                    on=self._parse_value(values=False) if self._match(TokenType.ON) else None,
3320                )
3321
3322            if all_ and distinct:
3323                self.raise_error("Cannot specify both ALL and DISTINCT after SELECT")
3324
3325            operation_modifiers = []
3326            while self._curr and self._match_texts(self.OPERATION_MODIFIERS):
3327                operation_modifiers.append(exp.var(self._prev.text.upper()))
3328
3329            limit = self._parse_limit(top=True)
3330            projections = self._parse_projections()
3331
3332            this = self.expression(
3333                exp.Select,
3334                kind=kind,
3335                hint=hint,
3336                distinct=distinct,
3337                expressions=projections,
3338                limit=limit,
3339                operation_modifiers=operation_modifiers or None,
3340            )
3341            this.comments = comments
3342
3343            into = self._parse_into()
3344            if into:
3345                this.set("into", into)
3346
3347            if not from_:
3348                from_ = self._parse_from()
3349
3350            if from_:
3351                this.set("from", from_)
3352
3353            this = self._parse_query_modifiers(this)
3354        elif (table or nested) and self._match(TokenType.L_PAREN):
3355            this = self._parse_wrapped_select(table=table)
3356
3357            # We return early here so that the UNION isn't attached to the subquery by the
3358            # following call to _parse_set_operations, but instead becomes the parent node
3359            self._match_r_paren()
3360            return self._parse_subquery(this, parse_alias=parse_subquery_alias)
3361        elif self._match(TokenType.VALUES, advance=False):
3362            this = self._parse_derived_table_values()
3363        elif from_:
3364            this = exp.select("*").from_(from_.this, copy=False)
3365        elif self._match(TokenType.SUMMARIZE):
3366            table = self._match(TokenType.TABLE)
3367            this = self._parse_select() or self._parse_string() or self._parse_table()
3368            return self.expression(exp.Summarize, this=this, table=table)
3369        elif self._match(TokenType.DESCRIBE):
3370            this = self._parse_describe()
3371        elif self._match_text_seq("STREAM"):
3372            this = self._parse_function()
3373            if this:
3374                this = self.expression(exp.Stream, this=this)
3375            else:
3376                self._retreat(self._index - 1)
3377        else:
3378            this = None
3379
3380        return self._parse_set_operations(this) if parse_set_operation else this
3381
3382    def _parse_recursive_with_search(self) -> t.Optional[exp.RecursiveWithSearch]:
3383        self._match_text_seq("SEARCH")
3384
3385        kind = self._match_texts(self.RECURSIVE_CTE_SEARCH_KIND) and self._prev.text.upper()
3386
3387        if not kind:
3388            return None
3389
3390        self._match_text_seq("FIRST", "BY")
3391
3392        return self.expression(
3393            exp.RecursiveWithSearch,
3394            kind=kind,
3395            this=self._parse_id_var(),
3396            expression=self._match_text_seq("SET") and self._parse_id_var(),
3397            using=self._match_text_seq("USING") and self._parse_id_var(),
3398        )
3399
3400    def _parse_with(self, skip_with_token: bool = False) -> t.Optional[exp.With]:
3401        if not skip_with_token and not self._match(TokenType.WITH):
3402            return None
3403
3404        comments = self._prev_comments
3405        recursive = self._match(TokenType.RECURSIVE)
3406
3407        last_comments = None
3408        expressions = []
3409        while True:
3410            cte = self._parse_cte()
3411            if isinstance(cte, exp.CTE):
3412                expressions.append(cte)
3413                if last_comments:
3414                    cte.add_comments(last_comments)
3415
3416            if not self._match(TokenType.COMMA) and not self._match(TokenType.WITH):
3417                break
3418            else:
3419                self._match(TokenType.WITH)
3420
3421            last_comments = self._prev_comments
3422
3423        return self.expression(
3424            exp.With,
3425            comments=comments,
3426            expressions=expressions,
3427            recursive=recursive,
3428            search=self._parse_recursive_with_search(),
3429        )
3430
3431    def _parse_cte(self) -> t.Optional[exp.CTE]:
3432        index = self._index
3433
3434        alias = self._parse_table_alias(self.ID_VAR_TOKENS)
3435        if not alias or not alias.this:
3436            self.raise_error("Expected CTE to have alias")
3437
3438        if not self._match(TokenType.ALIAS) and not self.OPTIONAL_ALIAS_TOKEN_CTE:
3439            self._retreat(index)
3440            return None
3441
3442        comments = self._prev_comments
3443
3444        if self._match_text_seq("NOT", "MATERIALIZED"):
3445            materialized = False
3446        elif self._match_text_seq("MATERIALIZED"):
3447            materialized = True
3448        else:
3449            materialized = None
3450
3451        cte = self.expression(
3452            exp.CTE,
3453            this=self._parse_wrapped(self._parse_statement),
3454            alias=alias,
3455            materialized=materialized,
3456            comments=comments,
3457        )
3458
3459        values = cte.this
3460        if isinstance(values, exp.Values):
3461            if values.alias:
3462                cte.set("this", exp.select("*").from_(values))
3463            else:
3464                cte.set("this", exp.select("*").from_(exp.alias_(values, "_values", table=True)))
3465
3466        return cte
3467
3468    def _parse_table_alias(
3469        self, alias_tokens: t.Optional[t.Collection[TokenType]] = None
3470    ) -> t.Optional[exp.TableAlias]:
3471        # In some dialects, LIMIT and OFFSET can act as both identifiers and keywords (clauses)
3472        # so this section tries to parse the clause version and if it fails, it treats the token
3473        # as an identifier (alias)
3474        if self._can_parse_limit_or_offset():
3475            return None
3476
3477        any_token = self._match(TokenType.ALIAS)
3478        alias = (
3479            self._parse_id_var(any_token=any_token, tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
3480            or self._parse_string_as_identifier()
3481        )
3482
3483        index = self._index
3484        if self._match(TokenType.L_PAREN):
3485            columns = self._parse_csv(self._parse_function_parameter)
3486            self._match_r_paren() if columns else self._retreat(index)
3487        else:
3488            columns = None
3489
3490        if not alias and not columns:
3491            return None
3492
3493        table_alias = self.expression(exp.TableAlias, this=alias, columns=columns)
3494
3495        # We bubble up comments from the Identifier to the TableAlias
3496        if isinstance(alias, exp.Identifier):
3497            table_alias.add_comments(alias.pop_comments())
3498
3499        return table_alias
3500
3501    def _parse_subquery(
3502        self, this: t.Optional[exp.Expression], parse_alias: bool = True
3503    ) -> t.Optional[exp.Subquery]:
3504        if not this:
3505            return None
3506
3507        return self.expression(
3508            exp.Subquery,
3509            this=this,
3510            pivots=self._parse_pivots(),
3511            alias=self._parse_table_alias() if parse_alias else None,
3512            sample=self._parse_table_sample(),
3513        )
3514
3515    def _implicit_unnests_to_explicit(self, this: E) -> E:
3516        from sqlglot.optimizer.normalize_identifiers import normalize_identifiers as _norm
3517
3518        refs = {_norm(this.args["from"].this.copy(), dialect=self.dialect).alias_or_name}
3519        for i, join in enumerate(this.args.get("joins") or []):
3520            table = join.this
3521            normalized_table = table.copy()
3522            normalized_table.meta["maybe_column"] = True
3523            normalized_table = _norm(normalized_table, dialect=self.dialect)
3524
3525            if isinstance(table, exp.Table) and not join.args.get("on"):
3526                if normalized_table.parts[0].name in refs:
3527                    table_as_column = table.to_column()
3528                    unnest = exp.Unnest(expressions=[table_as_column])
3529
3530                    # Table.to_column creates a parent Alias node that we want to convert to
3531                    # a TableAlias and attach to the Unnest, so it matches the parser's output
3532                    if isinstance(table.args.get("alias"), exp.TableAlias):
3533                        table_as_column.replace(table_as_column.this)
3534                        exp.alias_(unnest, None, table=[table.args["alias"].this], copy=False)
3535
3536                    table.replace(unnest)
3537
3538            refs.add(normalized_table.alias_or_name)
3539
3540        return this
3541
3542    def _parse_query_modifiers(
3543        self, this: t.Optional[exp.Expression]
3544    ) -> t.Optional[exp.Expression]:
3545        if isinstance(this, self.MODIFIABLES):
3546            for join in self._parse_joins():
3547                this.append("joins", join)
3548            for lateral in iter(self._parse_lateral, None):
3549                this.append("laterals", lateral)
3550
3551            while True:
3552                if self._match_set(self.QUERY_MODIFIER_PARSERS, advance=False):
3553                    modifier_token = self._curr
3554                    parser = self.QUERY_MODIFIER_PARSERS[modifier_token.token_type]
3555                    key, expression = parser(self)
3556
3557                    if expression:
3558                        if this.args.get(key):
3559                            self.raise_error(
3560                                f"Found multiple '{modifier_token.text.upper()}' clauses",
3561                                token=modifier_token,
3562                            )
3563
3564                        this.set(key, expression)
3565                        if key == "limit":
3566                            offset = expression.args.pop("offset", None)
3567
3568                            if offset:
3569                                offset = exp.Offset(expression=offset)
3570                                this.set("offset", offset)
3571
3572                                limit_by_expressions = expression.expressions
3573                                expression.set("expressions", None)
3574                                offset.set("expressions", limit_by_expressions)
3575                        continue
3576                break
3577
3578        if self.SUPPORTS_IMPLICIT_UNNEST and this and this.args.get("from"):
3579            this = self._implicit_unnests_to_explicit(this)
3580
3581        return this
3582
3583    def _parse_hint_fallback_to_string(self) -> t.Optional[exp.Hint]:
3584        start = self._curr
3585        while self._curr:
3586            self._advance()
3587
3588        end = self._tokens[self._index - 1]
3589        return exp.Hint(expressions=[self._find_sql(start, end)])
3590
3591    def _parse_hint_function_call(self) -> t.Optional[exp.Expression]:
3592        return self._parse_function_call()
3593
3594    def _parse_hint_body(self) -> t.Optional[exp.Hint]:
3595        start_index = self._index
3596        should_fallback_to_string = False
3597
3598        hints = []
3599        try:
3600            for hint in iter(
3601                lambda: self._parse_csv(
3602                    lambda: self._parse_hint_function_call() or self._parse_var(upper=True),
3603                ),
3604                [],
3605            ):
3606                hints.extend(hint)
3607        except ParseError:
3608            should_fallback_to_string = True
3609
3610        if should_fallback_to_string or self._curr:
3611            self._retreat(start_index)
3612            return self._parse_hint_fallback_to_string()
3613
3614        return self.expression(exp.Hint, expressions=hints)
3615
3616    def _parse_hint(self) -> t.Optional[exp.Hint]:
3617        if self._match(TokenType.HINT) and self._prev_comments:
3618            return exp.maybe_parse(self._prev_comments[0], into=exp.Hint, dialect=self.dialect)
3619
3620        return None
3621
3622    def _parse_into(self) -> t.Optional[exp.Into]:
3623        if not self._match(TokenType.INTO):
3624            return None
3625
3626        temp = self._match(TokenType.TEMPORARY)
3627        unlogged = self._match_text_seq("UNLOGGED")
3628        self._match(TokenType.TABLE)
3629
3630        return self.expression(
3631            exp.Into, this=self._parse_table(schema=True), temporary=temp, unlogged=unlogged
3632        )
3633
3634    def _parse_from(
3635        self,
3636        joins: bool = False,
3637        skip_from_token: bool = False,
3638        consume_pipe: bool = False,
3639    ) -> t.Optional[exp.From]:
3640        if not skip_from_token and not self._match(TokenType.FROM):
3641            return None
3642
3643        return self.expression(
3644            exp.From,
3645            comments=self._prev_comments,
3646            this=self._parse_table(joins=joins, consume_pipe=consume_pipe),
3647        )
3648
3649    def _parse_match_recognize_measure(self) -> exp.MatchRecognizeMeasure:
3650        return self.expression(
3651            exp.MatchRecognizeMeasure,
3652            window_frame=self._match_texts(("FINAL", "RUNNING")) and self._prev.text.upper(),
3653            this=self._parse_expression(),
3654        )
3655
3656    def _parse_match_recognize(self) -> t.Optional[exp.MatchRecognize]:
3657        if not self._match(TokenType.MATCH_RECOGNIZE):
3658            return None
3659
3660        self._match_l_paren()
3661
3662        partition = self._parse_partition_by()
3663        order = self._parse_order()
3664
3665        measures = (
3666            self._parse_csv(self._parse_match_recognize_measure)
3667            if self._match_text_seq("MEASURES")
3668            else None
3669        )
3670
3671        if self._match_text_seq("ONE", "ROW", "PER", "MATCH"):
3672            rows = exp.var("ONE ROW PER MATCH")
3673        elif self._match_text_seq("ALL", "ROWS", "PER", "MATCH"):
3674            text = "ALL ROWS PER MATCH"
3675            if self._match_text_seq("SHOW", "EMPTY", "MATCHES"):
3676                text += " SHOW EMPTY MATCHES"
3677            elif self._match_text_seq("OMIT", "EMPTY", "MATCHES"):
3678                text += " OMIT EMPTY MATCHES"
3679            elif self._match_text_seq("WITH", "UNMATCHED", "ROWS"):
3680                text += " WITH UNMATCHED ROWS"
3681            rows = exp.var(text)
3682        else:
3683            rows = None
3684
3685        if self._match_text_seq("AFTER", "MATCH", "SKIP"):
3686            text = "AFTER MATCH SKIP"
3687            if self._match_text_seq("PAST", "LAST", "ROW"):
3688                text += " PAST LAST ROW"
3689            elif self._match_text_seq("TO", "NEXT", "ROW"):
3690                text += " TO NEXT ROW"
3691            elif self._match_text_seq("TO", "FIRST"):
3692                text += f" TO FIRST {self._advance_any().text}"  # type: ignore
3693            elif self._match_text_seq("TO", "LAST"):
3694                text += f" TO LAST {self._advance_any().text}"  # type: ignore
3695            after = exp.var(text)
3696        else:
3697            after = None
3698
3699        if self._match_text_seq("PATTERN"):
3700            self._match_l_paren()
3701
3702            if not self._curr:
3703                self.raise_error("Expecting )", self._curr)
3704
3705            paren = 1
3706            start = self._curr
3707
3708            while self._curr and paren > 0:
3709                if self._curr.token_type == TokenType.L_PAREN:
3710                    paren += 1
3711                if self._curr.token_type == TokenType.R_PAREN:
3712                    paren -= 1
3713
3714                end = self._prev
3715                self._advance()
3716
3717            if paren > 0:
3718                self.raise_error("Expecting )", self._curr)
3719
3720            pattern = exp.var(self._find_sql(start, end))
3721        else:
3722            pattern = None
3723
3724        define = (
3725            self._parse_csv(self._parse_name_as_expression)
3726            if self._match_text_seq("DEFINE")
3727            else None
3728        )
3729
3730        self._match_r_paren()
3731
3732        return self.expression(
3733            exp.MatchRecognize,
3734            partition_by=partition,
3735            order=order,
3736            measures=measures,
3737            rows=rows,
3738            after=after,
3739            pattern=pattern,
3740            define=define,
3741            alias=self._parse_table_alias(),
3742        )
3743
3744    def _parse_lateral(self) -> t.Optional[exp.Lateral]:
3745        cross_apply = self._match_pair(TokenType.CROSS, TokenType.APPLY)
3746        if not cross_apply and self._match_pair(TokenType.OUTER, TokenType.APPLY):
3747            cross_apply = False
3748
3749        if cross_apply is not None:
3750            this = self._parse_select(table=True)
3751            view = None
3752            outer = None
3753        elif self._match(TokenType.LATERAL):
3754            this = self._parse_select(table=True)
3755            view = self._match(TokenType.VIEW)
3756            outer = self._match(TokenType.OUTER)
3757        else:
3758            return None
3759
3760        if not this:
3761            this = (
3762                self._parse_unnest()
3763                or self._parse_function()
3764                or self._parse_id_var(any_token=False)
3765            )
3766
3767            while self._match(TokenType.DOT):
3768                this = exp.Dot(
3769                    this=this,
3770                    expression=self._parse_function() or self._parse_id_var(any_token=False),
3771                )
3772
3773        ordinality: t.Optional[bool] = None
3774
3775        if view:
3776            table = self._parse_id_var(any_token=False)
3777            columns = self._parse_csv(self._parse_id_var) if self._match(TokenType.ALIAS) else []
3778            table_alias: t.Optional[exp.TableAlias] = self.expression(
3779                exp.TableAlias, this=table, columns=columns
3780            )
3781        elif isinstance(this, (exp.Subquery, exp.Unnest)) and this.alias:
3782            # We move the alias from the lateral's child node to the lateral itself
3783            table_alias = this.args["alias"].pop()
3784        else:
3785            ordinality = self._match_pair(TokenType.WITH, TokenType.ORDINALITY)
3786            table_alias = self._parse_table_alias()
3787
3788        return self.expression(
3789            exp.Lateral,
3790            this=this,
3791            view=view,
3792            outer=outer,
3793            alias=table_alias,
3794            cross_apply=cross_apply,
3795            ordinality=ordinality,
3796        )
3797
3798    def _parse_join_parts(
3799        self,
3800    ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
3801        return (
3802            self._match_set(self.JOIN_METHODS) and self._prev,
3803            self._match_set(self.JOIN_SIDES) and self._prev,
3804            self._match_set(self.JOIN_KINDS) and self._prev,
3805        )
3806
3807    def _parse_using_identifiers(self) -> t.List[exp.Expression]:
3808        def _parse_column_as_identifier() -> t.Optional[exp.Expression]:
3809            this = self._parse_column()
3810            if isinstance(this, exp.Column):
3811                return this.this
3812            return this
3813
3814        return self._parse_wrapped_csv(_parse_column_as_identifier, optional=True)
3815
3816    def _parse_join(
3817        self, skip_join_token: bool = False, parse_bracket: bool = False
3818    ) -> t.Optional[exp.Join]:
3819        if self._match(TokenType.COMMA):
3820            table = self._try_parse(self._parse_table)
3821            cross_join = self.expression(exp.Join, this=table) if table else None
3822
3823            if cross_join and self.JOINS_HAVE_EQUAL_PRECEDENCE:
3824                cross_join.set("kind", "CROSS")
3825
3826            return cross_join
3827
3828        index = self._index
3829        method, side, kind = self._parse_join_parts()
3830        hint = self._prev.text if self._match_texts(self.JOIN_HINTS) else None
3831        join = self._match(TokenType.JOIN) or (kind and kind.token_type == TokenType.STRAIGHT_JOIN)
3832        join_comments = self._prev_comments
3833
3834        if not skip_join_token and not join:
3835            self._retreat(index)
3836            kind = None
3837            method = None
3838            side = None
3839
3840        outer_apply = self._match_pair(TokenType.OUTER, TokenType.APPLY, False)
3841        cross_apply = self._match_pair(TokenType.CROSS, TokenType.APPLY, False)
3842
3843        if not skip_join_token and not join and not outer_apply and not cross_apply:
3844            return None
3845
3846        kwargs: t.Dict[str, t.Any] = {"this": self._parse_table(parse_bracket=parse_bracket)}
3847        if kind and kind.token_type == TokenType.ARRAY and self._match(TokenType.COMMA):
3848            kwargs["expressions"] = self._parse_csv(
3849                lambda: self._parse_table(parse_bracket=parse_bracket)
3850            )
3851
3852        if method:
3853            kwargs["method"] = method.text
3854        if side:
3855            kwargs["side"] = side.text
3856        if kind:
3857            kwargs["kind"] = kind.text
3858        if hint:
3859            kwargs["hint"] = hint
3860
3861        if self._match(TokenType.MATCH_CONDITION):
3862            kwargs["match_condition"] = self._parse_wrapped(self._parse_comparison)
3863
3864        if self._match(TokenType.ON):
3865            kwargs["on"] = self._parse_assignment()
3866        elif self._match(TokenType.USING):
3867            kwargs["using"] = self._parse_using_identifiers()
3868        elif (
3869            not method
3870            and not (outer_apply or cross_apply)
3871            and not isinstance(kwargs["this"], exp.Unnest)
3872            and not (kind and kind.token_type in (TokenType.CROSS, TokenType.ARRAY))
3873        ):
3874            index = self._index
3875            joins: t.Optional[list] = list(self._parse_joins())
3876
3877            if joins and self._match(TokenType.ON):
3878                kwargs["on"] = self._parse_assignment()
3879            elif joins and self._match(TokenType.USING):
3880                kwargs["using"] = self._parse_using_identifiers()
3881            else:
3882                joins = None
3883                self._retreat(index)
3884
3885            kwargs["this"].set("joins", joins if joins else None)
3886
3887        kwargs["pivots"] = self._parse_pivots()
3888
3889        comments = [c for token in (method, side, kind) if token for c in token.comments]
3890        comments = (join_comments or []) + comments
3891
3892        if (
3893            self.ADD_JOIN_ON_TRUE
3894            and not kwargs.get("on")
3895            and not kwargs.get("using")
3896            and not kwargs.get("method")
3897            and kwargs.get("kind") in (None, "INNER", "OUTER")
3898        ):
3899            kwargs["on"] = exp.true()
3900
3901        return self.expression(exp.Join, comments=comments, **kwargs)
3902
3903    def _parse_opclass(self) -> t.Optional[exp.Expression]:
3904        this = self._parse_assignment()
3905
3906        if self._match_texts(self.OPCLASS_FOLLOW_KEYWORDS, advance=False):
3907            return this
3908
3909        if not self._match_set(self.OPTYPE_FOLLOW_TOKENS, advance=False):
3910            return self.expression(exp.Opclass, this=this, expression=self._parse_table_parts())
3911
3912        return this
3913
3914    def _parse_index_params(self) -> exp.IndexParameters:
3915        using = self._parse_var(any_token=True) if self._match(TokenType.USING) else None
3916
3917        if self._match(TokenType.L_PAREN, advance=False):
3918            columns = self._parse_wrapped_csv(self._parse_with_operator)
3919        else:
3920            columns = None
3921
3922        include = self._parse_wrapped_id_vars() if self._match_text_seq("INCLUDE") else None
3923        partition_by = self._parse_partition_by()
3924        with_storage = self._match(TokenType.WITH) and self._parse_wrapped_properties()
3925        tablespace = (
3926            self._parse_var(any_token=True)
3927            if self._match_text_seq("USING", "INDEX", "TABLESPACE")
3928            else None
3929        )
3930        where = self._parse_where()
3931
3932        on = self._parse_field() if self._match(TokenType.ON) else None
3933
3934        return self.expression(
3935            exp.IndexParameters,
3936            using=using,
3937            columns=columns,
3938            include=include,
3939            partition_by=partition_by,
3940            where=where,
3941            with_storage=with_storage,
3942            tablespace=tablespace,
3943            on=on,
3944        )
3945
3946    def _parse_index(
3947        self, index: t.Optional[exp.Expression] = None, anonymous: bool = False
3948    ) -> t.Optional[exp.Index]:
3949        if index or anonymous:
3950            unique = None
3951            primary = None
3952            amp = None
3953
3954            self._match(TokenType.ON)
3955            self._match(TokenType.TABLE)  # hive
3956            table = self._parse_table_parts(schema=True)
3957        else:
3958            unique = self._match(TokenType.UNIQUE)
3959            primary = self._match_text_seq("PRIMARY")
3960            amp = self._match_text_seq("AMP")
3961
3962            if not self._match(TokenType.INDEX):
3963                return None
3964
3965            index = self._parse_id_var()
3966            table = None
3967
3968        params = self._parse_index_params()
3969
3970        return self.expression(
3971            exp.Index,
3972            this=index,
3973            table=table,
3974            unique=unique,
3975            primary=primary,
3976            amp=amp,
3977            params=params,
3978        )
3979
3980    def _parse_table_hints(self) -> t.Optional[t.List[exp.Expression]]:
3981        hints: t.List[exp.Expression] = []
3982        if self._match_pair(TokenType.WITH, TokenType.L_PAREN):
3983            # https://learn.microsoft.com/en-us/sql/t-sql/queries/hints-transact-sql-table?view=sql-server-ver16
3984            hints.append(
3985                self.expression(
3986                    exp.WithTableHint,
3987                    expressions=self._parse_csv(
3988                        lambda: self._parse_function() or self._parse_var(any_token=True)
3989                    ),
3990                )
3991            )
3992            self._match_r_paren()
3993        else:
3994            # https://dev.mysql.com/doc/refman/8.0/en/index-hints.html
3995            while self._match_set(self.TABLE_INDEX_HINT_TOKENS):
3996                hint = exp.IndexTableHint(this=self._prev.text.upper())
3997
3998                self._match_set((TokenType.INDEX, TokenType.KEY))
3999                if self._match(TokenType.FOR):
4000                    hint.set("target", self._advance_any() and self._prev.text.upper())
4001
4002                hint.set("expressions", self._parse_wrapped_id_vars())
4003                hints.append(hint)
4004
4005        return hints or None
4006
4007    def _parse_table_part(self, schema: bool = False) -> t.Optional[exp.Expression]:
4008        return (
4009            (not schema and self._parse_function(optional_parens=False))
4010            or self._parse_id_var(any_token=False)
4011            or self._parse_string_as_identifier()
4012            or self._parse_placeholder()
4013        )
4014
4015    def _parse_table_parts(
4016        self, schema: bool = False, is_db_reference: bool = False, wildcard: bool = False
4017    ) -> exp.Table:
4018        catalog = None
4019        db = None
4020        table: t.Optional[exp.Expression | str] = self._parse_table_part(schema=schema)
4021
4022        while self._match(TokenType.DOT):
4023            if catalog:
4024                # This allows nesting the table in arbitrarily many dot expressions if needed
4025                table = self.expression(
4026                    exp.Dot, this=table, expression=self._parse_table_part(schema=schema)
4027                )
4028            else:
4029                catalog = db
4030                db = table
4031                # "" used for tsql FROM a..b case
4032                table = self._parse_table_part(schema=schema) or ""
4033
4034        if (
4035            wildcard
4036            and self._is_connected()
4037            and (isinstance(table, exp.Identifier) or not table)
4038            and self._match(TokenType.STAR)
4039        ):
4040            if isinstance(table, exp.Identifier):
4041                table.args["this"] += "*"
4042            else:
4043                table = exp.Identifier(this="*")
4044
4045        # We bubble up comments from the Identifier to the Table
4046        comments = table.pop_comments() if isinstance(table, exp.Expression) else None
4047
4048        if is_db_reference:
4049            catalog = db
4050            db = table
4051            table = None
4052
4053        if not table and not is_db_reference:
4054            self.raise_error(f"Expected table name but got {self._curr}")
4055        if not db and is_db_reference:
4056            self.raise_error(f"Expected database name but got {self._curr}")
4057
4058        table = self.expression(
4059            exp.Table,
4060            comments=comments,
4061            this=table,
4062            db=db,
4063            catalog=catalog,
4064        )
4065
4066        changes = self._parse_changes()
4067        if changes:
4068            table.set("changes", changes)
4069
4070        at_before = self._parse_historical_data()
4071        if at_before:
4072            table.set("when", at_before)
4073
4074        pivots = self._parse_pivots()
4075        if pivots:
4076            table.set("pivots", pivots)
4077
4078        return table
4079
4080    def _parse_table(
4081        self,
4082        schema: bool = False,
4083        joins: bool = False,
4084        alias_tokens: t.Optional[t.Collection[TokenType]] = None,
4085        parse_bracket: bool = False,
4086        is_db_reference: bool = False,
4087        parse_partition: bool = False,
4088        consume_pipe: bool = False,
4089    ) -> t.Optional[exp.Expression]:
4090        lateral = self._parse_lateral()
4091        if lateral:
4092            return lateral
4093
4094        unnest = self._parse_unnest()
4095        if unnest:
4096            return unnest
4097
4098        values = self._parse_derived_table_values()
4099        if values:
4100            return values
4101
4102        subquery = self._parse_select(table=True, consume_pipe=consume_pipe)
4103        if subquery:
4104            if not subquery.args.get("pivots"):
4105                subquery.set("pivots", self._parse_pivots())
4106            return subquery
4107
4108        bracket = parse_bracket and self._parse_bracket(None)
4109        bracket = self.expression(exp.Table, this=bracket) if bracket else None
4110
4111        rows_from = self._match_text_seq("ROWS", "FROM") and self._parse_wrapped_csv(
4112            self._parse_table
4113        )
4114        rows_from = self.expression(exp.Table, rows_from=rows_from) if rows_from else None
4115
4116        only = self._match(TokenType.ONLY)
4117
4118        this = t.cast(
4119            exp.Expression,
4120            bracket
4121            or rows_from
4122            or self._parse_bracket(
4123                self._parse_table_parts(schema=schema, is_db_reference=is_db_reference)
4124            ),
4125        )
4126
4127        if only:
4128            this.set("only", only)
4129
4130        # Postgres supports a wildcard (table) suffix operator, which is a no-op in this context
4131        self._match_text_seq("*")
4132
4133        parse_partition = parse_partition or self.SUPPORTS_PARTITION_SELECTION
4134        if parse_partition and self._match(TokenType.PARTITION, advance=False):
4135            this.set("partition", self._parse_partition())
4136
4137        if schema:
4138            return self._parse_schema(this=this)
4139
4140        version = self._parse_version()
4141
4142        if version:
4143            this.set("version", version)
4144
4145        if self.dialect.ALIAS_POST_TABLESAMPLE:
4146            this.set("sample", self._parse_table_sample())
4147
4148        alias = self._parse_table_alias(alias_tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
4149        if alias:
4150            this.set("alias", alias)
4151
4152        if isinstance(this, exp.Table) and self._match_text_seq("AT"):
4153            return self.expression(
4154                exp.AtIndex, this=this.to_column(copy=False), expression=self._parse_id_var()
4155            )
4156
4157        this.set("hints", self._parse_table_hints())
4158
4159        if not this.args.get("pivots"):
4160            this.set("pivots", self._parse_pivots())
4161
4162        if not self.dialect.ALIAS_POST_TABLESAMPLE:
4163            this.set("sample", self._parse_table_sample())
4164
4165        if joins:
4166            for join in self._parse_joins():
4167                this.append("joins", join)
4168
4169        if self._match_pair(TokenType.WITH, TokenType.ORDINALITY):
4170            this.set("ordinality", True)
4171            this.set("alias", self._parse_table_alias())
4172
4173        return this
4174
4175    def _parse_version(self) -> t.Optional[exp.Version]:
4176        if self._match(TokenType.TIMESTAMP_SNAPSHOT):
4177            this = "TIMESTAMP"
4178        elif self._match(TokenType.VERSION_SNAPSHOT):
4179            this = "VERSION"
4180        else:
4181            return None
4182
4183        if self._match_set((TokenType.FROM, TokenType.BETWEEN)):
4184            kind = self._prev.text.upper()
4185            start = self._parse_bitwise()
4186            self._match_texts(("TO", "AND"))
4187            end = self._parse_bitwise()
4188            expression: t.Optional[exp.Expression] = self.expression(
4189                exp.Tuple, expressions=[start, end]
4190            )
4191        elif self._match_text_seq("CONTAINED", "IN"):
4192            kind = "CONTAINED IN"
4193            expression = self.expression(
4194                exp.Tuple, expressions=self._parse_wrapped_csv(self._parse_bitwise)
4195            )
4196        elif self._match(TokenType.ALL):
4197            kind = "ALL"
4198            expression = None
4199        else:
4200            self._match_text_seq("AS", "OF")
4201            kind = "AS OF"
4202            expression = self._parse_type()
4203
4204        return self.expression(exp.Version, this=this, expression=expression, kind=kind)
4205
4206    def _parse_historical_data(self) -> t.Optional[exp.HistoricalData]:
4207        # https://docs.snowflake.com/en/sql-reference/constructs/at-before
4208        index = self._index
4209        historical_data = None
4210        if self._match_texts(self.HISTORICAL_DATA_PREFIX):
4211            this = self._prev.text.upper()
4212            kind = (
4213                self._match(TokenType.L_PAREN)
4214                and self._match_texts(self.HISTORICAL_DATA_KIND)
4215                and self._prev.text.upper()
4216            )
4217            expression = self._match(TokenType.FARROW) and self._parse_bitwise()
4218
4219            if expression:
4220                self._match_r_paren()
4221                historical_data = self.expression(
4222                    exp.HistoricalData, this=this, kind=kind, expression=expression
4223                )
4224            else:
4225                self._retreat(index)
4226
4227        return historical_data
4228
4229    def _parse_changes(self) -> t.Optional[exp.Changes]:
4230        if not self._match_text_seq("CHANGES", "(", "INFORMATION", "=>"):
4231            return None
4232
4233        information = self._parse_var(any_token=True)
4234        self._match_r_paren()
4235
4236        return self.expression(
4237            exp.Changes,
4238            information=information,
4239            at_before=self._parse_historical_data(),
4240            end=self._parse_historical_data(),
4241        )
4242
4243    def _parse_unnest(self, with_alias: bool = True) -> t.Optional[exp.Unnest]:
4244        if not self._match_pair(TokenType.UNNEST, TokenType.L_PAREN, advance=False):
4245            return None
4246
4247        self._advance()
4248
4249        expressions = self._parse_wrapped_csv(self._parse_equality)
4250        offset = self._match_pair(TokenType.WITH, TokenType.ORDINALITY)
4251
4252        alias = self._parse_table_alias() if with_alias else None
4253
4254        if alias:
4255            if self.dialect.UNNEST_COLUMN_ONLY:
4256                if alias.args.get("columns"):
4257                    self.raise_error("Unexpected extra column alias in unnest.")
4258
4259                alias.set("columns", [alias.this])
4260                alias.set("this", None)
4261
4262            columns = alias.args.get("columns") or []
4263            if offset and len(expressions) < len(columns):
4264                offset = columns.pop()
4265
4266        if not offset and self._match_pair(TokenType.WITH, TokenType.OFFSET):
4267            self._match(TokenType.ALIAS)
4268            offset = self._parse_id_var(
4269                any_token=False, tokens=self.UNNEST_OFFSET_ALIAS_TOKENS
4270            ) or exp.to_identifier("offset")
4271
4272        return self.expression(exp.Unnest, expressions=expressions, alias=alias, offset=offset)
4273
4274    def _parse_derived_table_values(self) -> t.Optional[exp.Values]:
4275        is_derived = self._match_pair(TokenType.L_PAREN, TokenType.VALUES)
4276        if not is_derived and not (
4277            # ClickHouse's `FORMAT Values` is equivalent to `VALUES`
4278            self._match_text_seq("VALUES") or self._match_text_seq("FORMAT", "VALUES")
4279        ):
4280            return None
4281
4282        expressions = self._parse_csv(self._parse_value)
4283        alias = self._parse_table_alias()
4284
4285        if is_derived:
4286            self._match_r_paren()
4287
4288        return self.expression(
4289            exp.Values, expressions=expressions, alias=alias or self._parse_table_alias()
4290        )
4291
4292    def _parse_table_sample(self, as_modifier: bool = False) -> t.Optional[exp.TableSample]:
4293        if not self._match(TokenType.TABLE_SAMPLE) and not (
4294            as_modifier and self._match_text_seq("USING", "SAMPLE")
4295        ):
4296            return None
4297
4298        bucket_numerator = None
4299        bucket_denominator = None
4300        bucket_field = None
4301        percent = None
4302        size = None
4303        seed = None
4304
4305        method = self._parse_var(tokens=(TokenType.ROW,), upper=True)
4306        matched_l_paren = self._match(TokenType.L_PAREN)
4307
4308        if self.TABLESAMPLE_CSV:
4309            num = None
4310            expressions = self._parse_csv(self._parse_primary)
4311        else:
4312            expressions = None
4313            num = (
4314                self._parse_factor()
4315                if self._match(TokenType.NUMBER, advance=False)
4316                else self._parse_primary() or self._parse_placeholder()
4317            )
4318
4319        if self._match_text_seq("BUCKET"):
4320            bucket_numerator = self._parse_number()
4321            self._match_text_seq("OUT", "OF")
4322            bucket_denominator = bucket_denominator = self._parse_number()
4323            self._match(TokenType.ON)
4324            bucket_field = self._parse_field()
4325        elif self._match_set((TokenType.PERCENT, TokenType.MOD)):
4326            percent = num
4327        elif self._match(TokenType.ROWS) or not self.dialect.TABLESAMPLE_SIZE_IS_PERCENT:
4328            size = num
4329        else:
4330            percent = num
4331
4332        if matched_l_paren:
4333            self._match_r_paren()
4334
4335        if self._match(TokenType.L_PAREN):
4336            method = self._parse_var(upper=True)
4337            seed = self._match(TokenType.COMMA) and self._parse_number()
4338            self._match_r_paren()
4339        elif self._match_texts(("SEED", "REPEATABLE")):
4340            seed = self._parse_wrapped(self._parse_number)
4341
4342        if not method and self.DEFAULT_SAMPLING_METHOD:
4343            method = exp.var(self.DEFAULT_SAMPLING_METHOD)
4344
4345        return self.expression(
4346            exp.TableSample,
4347            expressions=expressions,
4348            method=method,
4349            bucket_numerator=bucket_numerator,
4350            bucket_denominator=bucket_denominator,
4351            bucket_field=bucket_field,
4352            percent=percent,
4353            size=size,
4354            seed=seed,
4355        )
4356
4357    def _parse_pivots(self) -> t.Optional[t.List[exp.Pivot]]:
4358        return list(iter(self._parse_pivot, None)) or None
4359
4360    def _parse_joins(self) -> t.Iterator[exp.Join]:
4361        return iter(self._parse_join, None)
4362
4363    def _parse_unpivot_columns(self) -> t.Optional[exp.UnpivotColumns]:
4364        if not self._match(TokenType.INTO):
4365            return None
4366
4367        return self.expression(
4368            exp.UnpivotColumns,
4369            this=self._match_text_seq("NAME") and self._parse_column(),
4370            expressions=self._match_text_seq("VALUE") and self._parse_csv(self._parse_column),
4371        )
4372
4373    # https://duckdb.org/docs/sql/statements/pivot
4374    def _parse_simplified_pivot(self, is_unpivot: t.Optional[bool] = None) -> exp.Pivot:
4375        def _parse_on() -> t.Optional[exp.Expression]:
4376            this = self._parse_bitwise()
4377
4378            if self._match(TokenType.IN):
4379                # PIVOT ... ON col IN (row_val1, row_val2)
4380                return self._parse_in(this)
4381            if self._match(TokenType.ALIAS, advance=False):
4382                # UNPIVOT ... ON (col1, col2, col3) AS row_val
4383                return self._parse_alias(this)
4384
4385            return this
4386
4387        this = self._parse_table()
4388        expressions = self._match(TokenType.ON) and self._parse_csv(_parse_on)
4389        into = self._parse_unpivot_columns()
4390        using = self._match(TokenType.USING) and self._parse_csv(
4391            lambda: self._parse_alias(self._parse_function())
4392        )
4393        group = self._parse_group()
4394
4395        return self.expression(
4396            exp.Pivot,
4397            this=this,
4398            expressions=expressions,
4399            using=using,
4400            group=group,
4401            unpivot=is_unpivot,
4402            into=into,
4403        )
4404
4405    def _parse_pivot_in(self) -> exp.In:
4406        def _parse_aliased_expression() -> t.Optional[exp.Expression]:
4407            this = self._parse_select_or_expression()
4408
4409            self._match(TokenType.ALIAS)
4410            alias = self._parse_bitwise()
4411            if alias:
4412                if isinstance(alias, exp.Column) and not alias.db:
4413                    alias = alias.this
4414                return self.expression(exp.PivotAlias, this=this, alias=alias)
4415
4416            return this
4417
4418        value = self._parse_column()
4419
4420        if not self._match_pair(TokenType.IN, TokenType.L_PAREN):
4421            self.raise_error("Expecting IN (")
4422
4423        if self._match(TokenType.ANY):
4424            exprs: t.List[exp.Expression] = ensure_list(exp.PivotAny(this=self._parse_order()))
4425        else:
4426            exprs = self._parse_csv(_parse_aliased_expression)
4427
4428        self._match_r_paren()
4429        return self.expression(exp.In, this=value, expressions=exprs)
4430
4431    def _parse_pivot_aggregation(self) -> t.Optional[exp.Expression]:
4432        func = self._parse_function()
4433        if not func:
4434            if self._prev and self._prev.token_type == TokenType.COMMA:
4435                return None
4436            self.raise_error("Expecting an aggregation function in PIVOT")
4437
4438        return self._parse_alias(func)
4439
4440    def _parse_pivot(self) -> t.Optional[exp.Pivot]:
4441        index = self._index
4442        include_nulls = None
4443
4444        if self._match(TokenType.PIVOT):
4445            unpivot = False
4446        elif self._match(TokenType.UNPIVOT):
4447            unpivot = True
4448
4449            # https://docs.databricks.com/en/sql/language-manual/sql-ref-syntax-qry-select-unpivot.html#syntax
4450            if self._match_text_seq("INCLUDE", "NULLS"):
4451                include_nulls = True
4452            elif self._match_text_seq("EXCLUDE", "NULLS"):
4453                include_nulls = False
4454        else:
4455            return None
4456
4457        expressions = []
4458
4459        if not self._match(TokenType.L_PAREN):
4460            self._retreat(index)
4461            return None
4462
4463        if unpivot:
4464            expressions = self._parse_csv(self._parse_column)
4465        else:
4466            expressions = self._parse_csv(self._parse_pivot_aggregation)
4467
4468        if not expressions:
4469            self.raise_error("Failed to parse PIVOT's aggregation list")
4470
4471        if not self._match(TokenType.FOR):
4472            self.raise_error("Expecting FOR")
4473
4474        fields = []
4475        while True:
4476            field = self._try_parse(self._parse_pivot_in)
4477            if not field:
4478                break
4479            fields.append(field)
4480
4481        default_on_null = self._match_text_seq("DEFAULT", "ON", "NULL") and self._parse_wrapped(
4482            self._parse_bitwise
4483        )
4484
4485        group = self._parse_group()
4486
4487        self._match_r_paren()
4488
4489        pivot = self.expression(
4490            exp.Pivot,
4491            expressions=expressions,
4492            fields=fields,
4493            unpivot=unpivot,
4494            include_nulls=include_nulls,
4495            default_on_null=default_on_null,
4496            group=group,
4497        )
4498
4499        if not self._match_set((TokenType.PIVOT, TokenType.UNPIVOT), advance=False):
4500            pivot.set("alias", self._parse_table_alias())
4501
4502        if not unpivot:
4503            names = self._pivot_column_names(t.cast(t.List[exp.Expression], expressions))
4504
4505            columns: t.List[exp.Expression] = []
4506            all_fields = []
4507            for pivot_field in pivot.fields:
4508                pivot_field_expressions = pivot_field.expressions
4509
4510                # The `PivotAny` expression corresponds to `ANY ORDER BY <column>`; we can't infer in this case.
4511                if isinstance(seq_get(pivot_field_expressions, 0), exp.PivotAny):
4512                    continue
4513
4514                all_fields.append(
4515                    [
4516                        fld.sql() if self.IDENTIFY_PIVOT_STRINGS else fld.alias_or_name
4517                        for fld in pivot_field_expressions
4518                    ]
4519                )
4520
4521            if all_fields:
4522                if names:
4523                    all_fields.append(names)
4524
4525                # Generate all possible combinations of the pivot columns
4526                # e.g PIVOT(sum(...) as total FOR year IN (2000, 2010) FOR country IN ('NL', 'US'))
4527                # generates the product between [[2000, 2010], ['NL', 'US'], ['total']]
4528                for fld_parts_tuple in itertools.product(*all_fields):
4529                    fld_parts = list(fld_parts_tuple)
4530
4531                    if names and self.PREFIXED_PIVOT_COLUMNS:
4532                        # Move the "name" to the front of the list
4533                        fld_parts.insert(0, fld_parts.pop(-1))
4534
4535                    columns.append(exp.to_identifier("_".join(fld_parts)))
4536
4537            pivot.set("columns", columns)
4538
4539        return pivot
4540
4541    def _pivot_column_names(self, aggregations: t.List[exp.Expression]) -> t.List[str]:
4542        return [agg.alias for agg in aggregations if agg.alias]
4543
4544    def _parse_prewhere(self, skip_where_token: bool = False) -> t.Optional[exp.PreWhere]:
4545        if not skip_where_token and not self._match(TokenType.PREWHERE):
4546            return None
4547
4548        return self.expression(
4549            exp.PreWhere, comments=self._prev_comments, this=self._parse_assignment()
4550        )
4551
4552    def _parse_where(self, skip_where_token: bool = False) -> t.Optional[exp.Where]:
4553        if not skip_where_token and not self._match(TokenType.WHERE):
4554            return None
4555
4556        return self.expression(
4557            exp.Where, comments=self._prev_comments, this=self._parse_assignment()
4558        )
4559
4560    def _parse_group(self, skip_group_by_token: bool = False) -> t.Optional[exp.Group]:
4561        if not skip_group_by_token and not self._match(TokenType.GROUP_BY):
4562            return None
4563        comments = self._prev_comments
4564
4565        elements: t.Dict[str, t.Any] = defaultdict(list)
4566
4567        if self._match(TokenType.ALL):
4568            elements["all"] = True
4569        elif self._match(TokenType.DISTINCT):
4570            elements["all"] = False
4571
4572        if self._match_set(self.QUERY_MODIFIER_TOKENS, advance=False):
4573            return self.expression(exp.Group, comments=comments, **elements)  # type: ignore
4574
4575        while True:
4576            index = self._index
4577
4578            elements["expressions"].extend(
4579                self._parse_csv(
4580                    lambda: None
4581                    if self._match_set((TokenType.CUBE, TokenType.ROLLUP), advance=False)
4582                    else self._parse_assignment()
4583                )
4584            )
4585
4586            before_with_index = self._index
4587            with_prefix = self._match(TokenType.WITH)
4588
4589            cube_or_rollup = self._parse_cube_or_rollup(with_prefix=with_prefix)
4590            if cube_or_rollup:
4591                key = "rollup" if isinstance(cube_or_rollup, exp.Rollup) else "cube"
4592                elements[key].append(cube_or_rollup)
4593            elif self._match(TokenType.GROUPING_SETS):
4594                elements["grouping_sets"].append(
4595                    self.expression(
4596                        exp.GroupingSets,
4597                        expressions=self._parse_wrapped_csv(self._parse_grouping_set),
4598                    )
4599                )
4600            elif self._match_text_seq("TOTALS"):
4601                elements["totals"] = True  # type: ignore
4602
4603            if before_with_index <= self._index <= before_with_index + 1:
4604                self._retreat(before_with_index)
4605                break
4606
4607            if index == self._index:
4608                break
4609
4610        return self.expression(exp.Group, comments=comments, **elements)  # type: ignore
4611
4612    def _parse_cube_or_rollup(self, with_prefix: bool = False) -> t.Optional[exp.Cube | exp.Rollup]:
4613        if self._match(TokenType.CUBE):
4614            kind: t.Type[exp.Cube | exp.Rollup] = exp.Cube
4615        elif self._match(TokenType.ROLLUP):
4616            kind = exp.Rollup
4617        else:
4618            return None
4619
4620        return self.expression(
4621            kind, expressions=[] if with_prefix else self._parse_wrapped_csv(self._parse_column)
4622        )
4623
4624    def _parse_grouping_set(self) -> t.Optional[exp.Expression]:
4625        return self._parse_cube_or_rollup() or self._parse_bitwise()
4626
4627    def _parse_having(self, skip_having_token: bool = False) -> t.Optional[exp.Having]:
4628        if not skip_having_token and not self._match(TokenType.HAVING):
4629            return None
4630        return self.expression(
4631            exp.Having, comments=self._prev_comments, this=self._parse_assignment()
4632        )
4633
4634    def _parse_qualify(self) -> t.Optional[exp.Qualify]:
4635        if not self._match(TokenType.QUALIFY):
4636            return None
4637        return self.expression(exp.Qualify, this=self._parse_assignment())
4638
4639    def _parse_connect_with_prior(self) -> t.Optional[exp.Expression]:
4640        self.NO_PAREN_FUNCTION_PARSERS["PRIOR"] = lambda self: self.expression(
4641            exp.Prior, this=self._parse_bitwise()
4642        )
4643        connect = self._parse_assignment()
4644        self.NO_PAREN_FUNCTION_PARSERS.pop("PRIOR")
4645        return connect
4646
4647    def _parse_connect(self, skip_start_token: bool = False) -> t.Optional[exp.Connect]:
4648        if skip_start_token:
4649            start = None
4650        elif self._match(TokenType.START_WITH):
4651            start = self._parse_assignment()
4652        else:
4653            return None
4654
4655        self._match(TokenType.CONNECT_BY)
4656        nocycle = self._match_text_seq("NOCYCLE")
4657        connect = self._parse_connect_with_prior()
4658
4659        if not start and self._match(TokenType.START_WITH):
4660            start = self._parse_assignment()
4661
4662        return self.expression(exp.Connect, start=start, connect=connect, nocycle=nocycle)
4663
4664    def _parse_name_as_expression(self) -> t.Optional[exp.Expression]:
4665        this = self._parse_id_var(any_token=True)
4666        if self._match(TokenType.ALIAS):
4667            this = self.expression(exp.Alias, alias=this, this=self._parse_assignment())
4668        return this
4669
4670    def _parse_interpolate(self) -> t.Optional[t.List[exp.Expression]]:
4671        if self._match_text_seq("INTERPOLATE"):
4672            return self._parse_wrapped_csv(self._parse_name_as_expression)
4673        return None
4674
4675    def _parse_order(
4676        self, this: t.Optional[exp.Expression] = None, skip_order_token: bool = False
4677    ) -> t.Optional[exp.Expression]:
4678        siblings = None
4679        if not skip_order_token and not self._match(TokenType.ORDER_BY):
4680            if not self._match(TokenType.ORDER_SIBLINGS_BY):
4681                return this
4682
4683            siblings = True
4684
4685        return self.expression(
4686            exp.Order,
4687            comments=self._prev_comments,
4688            this=this,
4689            expressions=self._parse_csv(self._parse_ordered),
4690            siblings=siblings,
4691        )
4692
4693    def _parse_sort(self, exp_class: t.Type[E], token: TokenType) -> t.Optional[E]:
4694        if not self._match(token):
4695            return None
4696        return self.expression(exp_class, expressions=self._parse_csv(self._parse_ordered))
4697
4698    def _parse_ordered(
4699        self, parse_method: t.Optional[t.Callable] = None
4700    ) -> t.Optional[exp.Ordered]:
4701        this = parse_method() if parse_method else self._parse_assignment()
4702        if not this:
4703            return None
4704
4705        if this.name.upper() == "ALL" and self.dialect.SUPPORTS_ORDER_BY_ALL:
4706            this = exp.var("ALL")
4707
4708        asc = self._match(TokenType.ASC)
4709        desc = self._match(TokenType.DESC) or (asc and False)
4710
4711        is_nulls_first = self._match_text_seq("NULLS", "FIRST")
4712        is_nulls_last = self._match_text_seq("NULLS", "LAST")
4713
4714        nulls_first = is_nulls_first or False
4715        explicitly_null_ordered = is_nulls_first or is_nulls_last
4716
4717        if (
4718            not explicitly_null_ordered
4719            and (
4720                (not desc and self.dialect.NULL_ORDERING == "nulls_are_small")
4721                or (desc and self.dialect.NULL_ORDERING != "nulls_are_small")
4722            )
4723            and self.dialect.NULL_ORDERING != "nulls_are_last"
4724        ):
4725            nulls_first = True
4726
4727        if self._match_text_seq("WITH", "FILL"):
4728            with_fill = self.expression(
4729                exp.WithFill,
4730                **{  # type: ignore
4731                    "from": self._match(TokenType.FROM) and self._parse_bitwise(),
4732                    "to": self._match_text_seq("TO") and self._parse_bitwise(),
4733                    "step": self._match_text_seq("STEP") and self._parse_bitwise(),
4734                    "interpolate": self._parse_interpolate(),
4735                },
4736            )
4737        else:
4738            with_fill = None
4739
4740        return self.expression(
4741            exp.Ordered, this=this, desc=desc, nulls_first=nulls_first, with_fill=with_fill
4742        )
4743
4744    def _parse_limit_options(self) -> t.Optional[exp.LimitOptions]:
4745        percent = self._match_set((TokenType.PERCENT, TokenType.MOD))
4746        rows = self._match_set((TokenType.ROW, TokenType.ROWS))
4747        self._match_text_seq("ONLY")
4748        with_ties = self._match_text_seq("WITH", "TIES")
4749
4750        if not (percent or rows or with_ties):
4751            return None
4752
4753        return self.expression(exp.LimitOptions, percent=percent, rows=rows, with_ties=with_ties)
4754
4755    def _parse_limit(
4756        self,
4757        this: t.Optional[exp.Expression] = None,
4758        top: bool = False,
4759        skip_limit_token: bool = False,
4760    ) -> t.Optional[exp.Expression]:
4761        if skip_limit_token or self._match(TokenType.TOP if top else TokenType.LIMIT):
4762            comments = self._prev_comments
4763            if top:
4764                limit_paren = self._match(TokenType.L_PAREN)
4765                expression = self._parse_term() if limit_paren else self._parse_number()
4766
4767                if limit_paren:
4768                    self._match_r_paren()
4769
4770            else:
4771                # Parsing LIMIT x% (i.e x PERCENT) as a term leads to an error, since
4772                # we try to build an exp.Mod expr. For that matter, we backtrack and instead
4773                # consume the factor plus parse the percentage separately
4774                expression = self._try_parse(self._parse_term) or self._parse_factor()
4775
4776            limit_options = self._parse_limit_options()
4777
4778            if self._match(TokenType.COMMA):
4779                offset = expression
4780                expression = self._parse_term()
4781            else:
4782                offset = None
4783
4784            limit_exp = self.expression(
4785                exp.Limit,
4786                this=this,
4787                expression=expression,
4788                offset=offset,
4789                comments=comments,
4790                limit_options=limit_options,
4791                expressions=self._parse_limit_by(),
4792            )
4793
4794            return limit_exp
4795
4796        if self._match(TokenType.FETCH):
4797            direction = self._match_set((TokenType.FIRST, TokenType.NEXT))
4798            direction = self._prev.text.upper() if direction else "FIRST"
4799
4800            count = self._parse_field(tokens=self.FETCH_TOKENS)
4801
4802            return self.expression(
4803                exp.Fetch,
4804                direction=direction,
4805                count=count,
4806                limit_options=self._parse_limit_options(),
4807            )
4808
4809        return this
4810
4811    def _parse_offset(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
4812        if not self._match(TokenType.OFFSET):
4813            return this
4814
4815        count = self._parse_term()
4816        self._match_set((TokenType.ROW, TokenType.ROWS))
4817
4818        return self.expression(
4819            exp.Offset, this=this, expression=count, expressions=self._parse_limit_by()
4820        )
4821
4822    def _can_parse_limit_or_offset(self) -> bool:
4823        if not self._match_set(self.AMBIGUOUS_ALIAS_TOKENS, advance=False):
4824            return False
4825
4826        index = self._index
4827        result = bool(
4828            self._try_parse(self._parse_limit, retreat=True)
4829            or self._try_parse(self._parse_offset, retreat=True)
4830        )
4831        self._retreat(index)
4832        return result
4833
4834    def _parse_limit_by(self) -> t.Optional[t.List[exp.Expression]]:
4835        return self._match_text_seq("BY") and self._parse_csv(self._parse_bitwise)
4836
4837    def _parse_locks(self) -> t.List[exp.Lock]:
4838        locks = []
4839        while True:
4840            update, key = None, None
4841            if self._match_text_seq("FOR", "UPDATE"):
4842                update = True
4843            elif self._match_text_seq("FOR", "SHARE") or self._match_text_seq(
4844                "LOCK", "IN", "SHARE", "MODE"
4845            ):
4846                update = False
4847            elif self._match_text_seq("FOR", "KEY", "SHARE"):
4848                update, key = False, True
4849            elif self._match_text_seq("FOR", "NO", "KEY", "UPDATE"):
4850                update, key = True, True
4851            else:
4852                break
4853
4854            expressions = None
4855            if self._match_text_seq("OF"):
4856                expressions = self._parse_csv(lambda: self._parse_table(schema=True))
4857
4858            wait: t.Optional[bool | exp.Expression] = None
4859            if self._match_text_seq("NOWAIT"):
4860                wait = True
4861            elif self._match_text_seq("WAIT"):
4862                wait = self._parse_primary()
4863            elif self._match_text_seq("SKIP", "LOCKED"):
4864                wait = False
4865
4866            locks.append(
4867                self.expression(
4868                    exp.Lock, update=update, expressions=expressions, wait=wait, key=key
4869                )
4870            )
4871
4872        return locks
4873
4874    def parse_set_operation(
4875        self, this: t.Optional[exp.Expression], consume_pipe: bool = False
4876    ) -> t.Optional[exp.Expression]:
4877        start = self._index
4878        _, side_token, kind_token = self._parse_join_parts()
4879
4880        side = side_token.text if side_token else None
4881        kind = kind_token.text if kind_token else None
4882
4883        if not self._match_set(self.SET_OPERATIONS):
4884            self._retreat(start)
4885            return None
4886
4887        token_type = self._prev.token_type
4888
4889        if token_type == TokenType.UNION:
4890            operation: t.Type[exp.SetOperation] = exp.Union
4891        elif token_type == TokenType.EXCEPT:
4892            operation = exp.Except
4893        else:
4894            operation = exp.Intersect
4895
4896        comments = self._prev.comments
4897
4898        if self._match(TokenType.DISTINCT):
4899            distinct: t.Optional[bool] = True
4900        elif self._match(TokenType.ALL):
4901            distinct = False
4902        else:
4903            distinct = self.dialect.SET_OP_DISTINCT_BY_DEFAULT[operation]
4904            if distinct is None:
4905                self.raise_error(f"Expected DISTINCT or ALL for {operation.__name__}")
4906
4907        by_name = self._match_text_seq("BY", "NAME") or self._match_text_seq(
4908            "STRICT", "CORRESPONDING"
4909        )
4910        if self._match_text_seq("CORRESPONDING"):
4911            by_name = True
4912            if not side and not kind:
4913                kind = "INNER"
4914
4915        on_column_list = None
4916        if by_name and self._match_texts(("ON", "BY")):
4917            on_column_list = self._parse_wrapped_csv(self._parse_column)
4918
4919        expression = self._parse_select(
4920            nested=True, parse_set_operation=False, consume_pipe=consume_pipe
4921        )
4922
4923        return self.expression(
4924            operation,
4925            comments=comments,
4926            this=this,
4927            distinct=distinct,
4928            by_name=by_name,
4929            expression=expression,
4930            side=side,
4931            kind=kind,
4932            on=on_column_list,
4933        )
4934
4935    def _parse_set_operations(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
4936        while this:
4937            setop = self.parse_set_operation(this)
4938            if not setop:
4939                break
4940            this = setop
4941
4942        if isinstance(this, exp.SetOperation) and self.MODIFIERS_ATTACHED_TO_SET_OP:
4943            expression = this.expression
4944
4945            if expression:
4946                for arg in self.SET_OP_MODIFIERS:
4947                    expr = expression.args.get(arg)
4948                    if expr:
4949                        this.set(arg, expr.pop())
4950
4951        return this
4952
4953    def _parse_expression(self) -> t.Optional[exp.Expression]:
4954        return self._parse_alias(self._parse_assignment())
4955
4956    def _parse_assignment(self) -> t.Optional[exp.Expression]:
4957        this = self._parse_disjunction()
4958        if not this and self._next and self._next.token_type in self.ASSIGNMENT:
4959            # This allows us to parse <non-identifier token> := <expr>
4960            this = exp.column(
4961                t.cast(str, self._advance_any(ignore_reserved=True) and self._prev.text)
4962            )
4963
4964        while self._match_set(self.ASSIGNMENT):
4965            if isinstance(this, exp.Column) and len(this.parts) == 1:
4966                this = this.this
4967
4968            this = self.expression(
4969                self.ASSIGNMENT[self._prev.token_type],
4970                this=this,
4971                comments=self._prev_comments,
4972                expression=self._parse_assignment(),
4973            )
4974
4975        return this
4976
4977    def _parse_disjunction(self) -> t.Optional[exp.Expression]:
4978        return self._parse_tokens(self._parse_conjunction, self.DISJUNCTION)
4979
4980    def _parse_conjunction(self) -> t.Optional[exp.Expression]:
4981        return self._parse_tokens(self._parse_equality, self.CONJUNCTION)
4982
4983    def _parse_equality(self) -> t.Optional[exp.Expression]:
4984        return self._parse_tokens(self._parse_comparison, self.EQUALITY)
4985
4986    def _parse_comparison(self) -> t.Optional[exp.Expression]:
4987        return self._parse_tokens(self._parse_range, self.COMPARISON)
4988
4989    def _parse_range(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
4990        this = this or self._parse_bitwise()
4991        negate = self._match(TokenType.NOT)
4992
4993        if self._match_set(self.RANGE_PARSERS):
4994            expression = self.RANGE_PARSERS[self._prev.token_type](self, this)
4995            if not expression:
4996                return this
4997
4998            this = expression
4999        elif self._match(TokenType.ISNULL):
5000            this = self.expression(exp.Is, this=this, expression=exp.Null())
5001
5002        # Postgres supports ISNULL and NOTNULL for conditions.
5003        # https://blog.andreiavram.ro/postgresql-null-composite-type/
5004        if self._match(TokenType.NOTNULL):
5005            this = self.expression(exp.Is, this=this, expression=exp.Null())
5006            this = self.expression(exp.Not, this=this)
5007
5008        if negate:
5009            this = self._negate_range(this)
5010
5011        if self._match(TokenType.IS):
5012            this = self._parse_is(this)
5013
5014        return this
5015
5016    def _negate_range(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
5017        if not this:
5018            return this
5019
5020        return self.expression(exp.Not, this=this)
5021
5022    def _parse_is(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
5023        index = self._index - 1
5024        negate = self._match(TokenType.NOT)
5025
5026        if self._match_text_seq("DISTINCT", "FROM"):
5027            klass = exp.NullSafeEQ if negate else exp.NullSafeNEQ
5028            return self.expression(klass, this=this, expression=self._parse_bitwise())
5029
5030        if self._match(TokenType.JSON):
5031            kind = self._match_texts(self.IS_JSON_PREDICATE_KIND) and self._prev.text.upper()
5032
5033            if self._match_text_seq("WITH"):
5034                _with = True
5035            elif self._match_text_seq("WITHOUT"):
5036                _with = False
5037            else:
5038                _with = None
5039
5040            unique = self._match(TokenType.UNIQUE)
5041            self._match_text_seq("KEYS")
5042            expression: t.Optional[exp.Expression] = self.expression(
5043                exp.JSON, **{"this": kind, "with": _with, "unique": unique}
5044            )
5045        else:
5046            expression = self._parse_primary() or self._parse_null()
5047            if not expression:
5048                self._retreat(index)
5049                return None
5050
5051        this = self.expression(exp.Is, this=this, expression=expression)
5052        return self.expression(exp.Not, this=this) if negate else this
5053
5054    def _parse_in(self, this: t.Optional[exp.Expression], alias: bool = False) -> exp.In:
5055        unnest = self._parse_unnest(with_alias=False)
5056        if unnest:
5057            this = self.expression(exp.In, this=this, unnest=unnest)
5058        elif self._match_set((TokenType.L_PAREN, TokenType.L_BRACKET)):
5059            matched_l_paren = self._prev.token_type == TokenType.L_PAREN
5060            expressions = self._parse_csv(lambda: self._parse_select_or_expression(alias=alias))
5061
5062            if len(expressions) == 1 and isinstance(expressions[0], exp.Query):
5063                this = self.expression(exp.In, this=this, query=expressions[0].subquery(copy=False))
5064            else:
5065                this = self.expression(exp.In, this=this, expressions=expressions)
5066
5067            if matched_l_paren:
5068                self._match_r_paren(this)
5069            elif not self._match(TokenType.R_BRACKET, expression=this):
5070                self.raise_error("Expecting ]")
5071        else:
5072            this = self.expression(exp.In, this=this, field=self._parse_column())
5073
5074        return this
5075
5076    def _parse_between(self, this: t.Optional[exp.Expression]) -> exp.Between:
5077        symmetric = None
5078        if self._match_text_seq("SYMMETRIC"):
5079            symmetric = True
5080        elif self._match_text_seq("ASYMMETRIC"):
5081            symmetric = False
5082
5083        low = self._parse_bitwise()
5084        self._match(TokenType.AND)
5085        high = self._parse_bitwise()
5086
5087        return self.expression(
5088            exp.Between,
5089            this=this,
5090            low=low,
5091            high=high,
5092            symmetric=symmetric,
5093        )
5094
5095    def _parse_escape(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
5096        if not self._match(TokenType.ESCAPE):
5097            return this
5098        return self.expression(exp.Escape, this=this, expression=self._parse_string())
5099
5100    def _parse_interval(self, match_interval: bool = True) -> t.Optional[exp.Add | exp.Interval]:
5101        index = self._index
5102
5103        if not self._match(TokenType.INTERVAL) and match_interval:
5104            return None
5105
5106        if self._match(TokenType.STRING, advance=False):
5107            this = self._parse_primary()
5108        else:
5109            this = self._parse_term()
5110
5111        if not this or (
5112            isinstance(this, exp.Column)
5113            and not this.table
5114            and not this.this.quoted
5115            and self._curr
5116            and self._curr.text.upper() not in self.dialect.VALID_INTERVAL_UNITS
5117        ):
5118            self._retreat(index)
5119            return None
5120
5121        # handle day-time format interval span with omitted units:
5122        #   INTERVAL '<number days> hh[:][mm[:ss[.ff]]]' <maybe `unit TO unit`>
5123        interval_span_units_omitted = None
5124        if (
5125            this
5126            and this.is_string
5127            and self.SUPPORTS_OMITTED_INTERVAL_SPAN_UNIT
5128            and exp.INTERVAL_DAY_TIME_RE.match(this.name)
5129        ):
5130            index = self._index
5131
5132            # Var "TO" Var
5133            first_unit = self._parse_var(any_token=True, upper=True)
5134            second_unit = None
5135            if first_unit and self._match_text_seq("TO"):
5136                second_unit = self._parse_var(any_token=True, upper=True)
5137
5138            interval_span_units_omitted = not (first_unit and second_unit)
5139
5140            self._retreat(index)
5141
5142        unit = (
5143            None
5144            if interval_span_units_omitted
5145            else (
5146                self._parse_function()
5147                or (
5148                    not self._match(TokenType.ALIAS, advance=False)
5149                    and self._parse_var(any_token=True, upper=True)
5150                )
5151            )
5152        )
5153
5154        # Most dialects support, e.g., the form INTERVAL '5' day, thus we try to parse
5155        # each INTERVAL expression into this canonical form so it's easy to transpile
5156        if this and this.is_number:
5157            this = exp.Literal.string(this.to_py())
5158        elif this and this.is_string:
5159            parts = exp.INTERVAL_STRING_RE.findall(this.name)
5160            if parts and unit:
5161                # Unconsume the eagerly-parsed unit, since the real unit was part of the string
5162                unit = None
5163                self._retreat(self._index - 1)
5164
5165            if len(parts) == 1:
5166                this = exp.Literal.string(parts[0][0])
5167                unit = self.expression(exp.Var, this=parts[0][1].upper())
5168
5169        if self.INTERVAL_SPANS and self._match_text_seq("TO"):
5170            unit = self.expression(
5171                exp.IntervalSpan, this=unit, expression=self._parse_var(any_token=True, upper=True)
5172            )
5173
5174        interval = self.expression(exp.Interval, this=this, unit=unit)
5175
5176        index = self._index
5177        self._match(TokenType.PLUS)
5178
5179        # Convert INTERVAL 'val_1' unit_1 [+] ... [+] 'val_n' unit_n into a sum of intervals
5180        if self._match_set((TokenType.STRING, TokenType.NUMBER), advance=False):
5181            return self.expression(
5182                exp.Add, this=interval, expression=self._parse_interval(match_interval=False)
5183            )
5184
5185        self._retreat(index)
5186        return interval
5187
5188    def _parse_bitwise(self) -> t.Optional[exp.Expression]:
5189        this = self._parse_term()
5190
5191        while True:
5192            if self._match_set(self.BITWISE):
5193                this = self.expression(
5194                    self.BITWISE[self._prev.token_type],
5195                    this=this,
5196                    expression=self._parse_term(),
5197                )
5198            elif self.dialect.DPIPE_IS_STRING_CONCAT and self._match(TokenType.DPIPE):
5199                this = self.expression(
5200                    exp.DPipe,
5201                    this=this,
5202                    expression=self._parse_term(),
5203                    safe=not self.dialect.STRICT_STRING_CONCAT,
5204                )
5205            elif self._match(TokenType.DQMARK):
5206                this = self.expression(
5207                    exp.Coalesce, this=this, expressions=ensure_list(self._parse_term())
5208                )
5209            elif self._match_pair(TokenType.LT, TokenType.LT):
5210                this = self.expression(
5211                    exp.BitwiseLeftShift, this=this, expression=self._parse_term()
5212                )
5213            elif self._match_pair(TokenType.GT, TokenType.GT):
5214                this = self.expression(
5215                    exp.BitwiseRightShift, this=this, expression=self._parse_term()
5216                )
5217            else:
5218                break
5219
5220        return this
5221
5222    def _parse_term(self) -> t.Optional[exp.Expression]:
5223        this = self._parse_factor()
5224
5225        while self._match_set(self.TERM):
5226            klass = self.TERM[self._prev.token_type]
5227            comments = self._prev_comments
5228            expression = self._parse_factor()
5229
5230            this = self.expression(klass, this=this, comments=comments, expression=expression)
5231
5232            if isinstance(this, exp.Collate):
5233                expr = this.expression
5234
5235                # Preserve collations such as pg_catalog."default" (Postgres) as columns, otherwise
5236                # fallback to Identifier / Var
5237                if isinstance(expr, exp.Column) and len(expr.parts) == 1:
5238                    ident = expr.this
5239                    if isinstance(ident, exp.Identifier):
5240                        this.set("expression", ident if ident.quoted else exp.var(ident.name))
5241
5242        return this
5243
5244    def _parse_factor(self) -> t.Optional[exp.Expression]:
5245        parse_method = self._parse_exponent if self.EXPONENT else self._parse_unary
5246        this = parse_method()
5247
5248        while self._match_set(self.FACTOR):
5249            klass = self.FACTOR[self._prev.token_type]
5250            comments = self._prev_comments
5251            expression = parse_method()
5252
5253            if not expression and klass is exp.IntDiv and self._prev.text.isalpha():
5254                self._retreat(self._index - 1)
5255                return this
5256
5257            this = self.expression(klass, this=this, comments=comments, expression=expression)
5258
5259            if isinstance(this, exp.Div):
5260                this.args["typed"] = self.dialect.TYPED_DIVISION
5261                this.args["safe"] = self.dialect.SAFE_DIVISION
5262
5263        return this
5264
5265    def _parse_exponent(self) -> t.Optional[exp.Expression]:
5266        return self._parse_tokens(self._parse_unary, self.EXPONENT)
5267
5268    def _parse_unary(self) -> t.Optional[exp.Expression]:
5269        if self._match_set(self.UNARY_PARSERS):
5270            return self.UNARY_PARSERS[self._prev.token_type](self)
5271        return self._parse_at_time_zone(self._parse_type())
5272
5273    def _parse_type(
5274        self, parse_interval: bool = True, fallback_to_identifier: bool = False
5275    ) -> t.Optional[exp.Expression]:
5276        interval = parse_interval and self._parse_interval()
5277        if interval:
5278            return interval
5279
5280        index = self._index
5281        data_type = self._parse_types(check_func=True, allow_identifiers=False)
5282
5283        # parse_types() returns a Cast if we parsed BQ's inline constructor <type>(<values>) e.g.
5284        # STRUCT<a INT, b STRING>(1, 'foo'), which is canonicalized to CAST(<values> AS <type>)
5285        if isinstance(data_type, exp.Cast):
5286            # This constructor can contain ops directly after it, for instance struct unnesting:
5287            # STRUCT<a INT, b STRING>(1, 'foo').* --> CAST(STRUCT(1, 'foo') AS STRUCT<a iNT, b STRING).*
5288            return self._parse_column_ops(data_type)
5289
5290        if data_type:
5291            index2 = self._index
5292            this = self._parse_primary()
5293
5294            if isinstance(this, exp.Literal):
5295                literal = this.name
5296                this = self._parse_column_ops(this)
5297
5298                parser = self.TYPE_LITERAL_PARSERS.get(data_type.this)
5299                if parser:
5300                    return parser(self, this, data_type)
5301
5302                if (
5303                    self.ZONE_AWARE_TIMESTAMP_CONSTRUCTOR
5304                    and data_type.is_type(exp.DataType.Type.TIMESTAMP)
5305                    and TIME_ZONE_RE.search(literal)
5306                ):
5307                    data_type = exp.DataType.build("TIMESTAMPTZ")
5308
5309                return self.expression(exp.Cast, this=this, to=data_type)
5310
5311            # The expressions arg gets set by the parser when we have something like DECIMAL(38, 0)
5312            # in the input SQL. In that case, we'll produce these tokens: DECIMAL ( 38 , 0 )
5313            #
5314            # If the index difference here is greater than 1, that means the parser itself must have
5315            # consumed additional tokens such as the DECIMAL scale and precision in the above example.
5316            #
5317            # If it's not greater than 1, then it must be 1, because we've consumed at least the type
5318            # keyword, meaning that the expressions arg of the DataType must have gotten set by a
5319            # callable in the TYPE_CONVERTERS mapping. For example, Snowflake converts DECIMAL to
5320            # DECIMAL(38, 0)) in order to facilitate the data type's transpilation.
5321            #
5322            # In these cases, we don't really want to return the converted type, but instead retreat
5323            # and try to parse a Column or Identifier in the section below.
5324            if data_type.expressions and index2 - index > 1:
5325                self._retreat(index2)
5326                return self._parse_column_ops(data_type)
5327
5328            self._retreat(index)
5329
5330        if fallback_to_identifier:
5331            return self._parse_id_var()
5332
5333        this = self._parse_column()
5334        return this and self._parse_column_ops(this)
5335
5336    def _parse_type_size(self) -> t.Optional[exp.DataTypeParam]:
5337        this = self._parse_type()
5338        if not this:
5339            return None
5340
5341        if isinstance(this, exp.Column) and not this.table:
5342            this = exp.var(this.name.upper())
5343
5344        return self.expression(
5345            exp.DataTypeParam, this=this, expression=self._parse_var(any_token=True)
5346        )
5347
5348    def _parse_user_defined_type(self, identifier: exp.Identifier) -> t.Optional[exp.Expression]:
5349        type_name = identifier.name
5350
5351        while self._match(TokenType.DOT):
5352            type_name = f"{type_name}.{self._advance_any() and self._prev.text}"
5353
5354        return exp.DataType.build(type_name, dialect=self.dialect, udt=True)
5355
5356    def _parse_types(
5357        self, check_func: bool = False, schema: bool = False, allow_identifiers: bool = True
5358    ) -> t.Optional[exp.Expression]:
5359        index = self._index
5360
5361        this: t.Optional[exp.Expression] = None
5362        prefix = self._match_text_seq("SYSUDTLIB", ".")
5363
5364        if self._match_set(self.TYPE_TOKENS):
5365            type_token = self._prev.token_type
5366        else:
5367            type_token = None
5368            identifier = allow_identifiers and self._parse_id_var(
5369                any_token=False, tokens=(TokenType.VAR,)
5370            )
5371            if isinstance(identifier, exp.Identifier):
5372                try:
5373                    tokens = self.dialect.tokenize(identifier.name)
5374                except TokenError:
5375                    tokens = None
5376
5377                if tokens and len(tokens) == 1 and tokens[0].token_type in self.TYPE_TOKENS:
5378                    type_token = tokens[0].token_type
5379                elif self.dialect.SUPPORTS_USER_DEFINED_TYPES:
5380                    this = self._parse_user_defined_type(identifier)
5381                else:
5382                    self._retreat(self._index - 1)
5383                    return None
5384            else:
5385                return None
5386
5387        if type_token == TokenType.PSEUDO_TYPE:
5388            return self.expression(exp.PseudoType, this=self._prev.text.upper())
5389
5390        if type_token == TokenType.OBJECT_IDENTIFIER:
5391            return self.expression(exp.ObjectIdentifier, this=self._prev.text.upper())
5392
5393        # https://materialize.com/docs/sql/types/map/
5394        if type_token == TokenType.MAP and self._match(TokenType.L_BRACKET):
5395            key_type = self._parse_types(
5396                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
5397            )
5398            if not self._match(TokenType.FARROW):
5399                self._retreat(index)
5400                return None
5401
5402            value_type = self._parse_types(
5403                check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
5404            )
5405            if not self._match(TokenType.R_BRACKET):
5406                self._retreat(index)
5407                return None
5408
5409            return exp.DataType(
5410                this=exp.DataType.Type.MAP,
5411                expressions=[key_type, value_type],
5412                nested=True,
5413                prefix=prefix,
5414            )
5415
5416        nested = type_token in self.NESTED_TYPE_TOKENS
5417        is_struct = type_token in self.STRUCT_TYPE_TOKENS
5418        is_aggregate = type_token in self.AGGREGATE_TYPE_TOKENS
5419        expressions = None
5420        maybe_func = False
5421
5422        if self._match(TokenType.L_PAREN):
5423            if is_struct:
5424                expressions = self._parse_csv(lambda: self._parse_struct_types(type_required=True))
5425            elif nested:
5426                expressions = self._parse_csv(
5427                    lambda: self._parse_types(
5428                        check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
5429                    )
5430                )
5431                if type_token == TokenType.NULLABLE and len(expressions) == 1:
5432                    this = expressions[0]
5433                    this.set("nullable", True)
5434                    self._match_r_paren()
5435                    return this
5436            elif type_token in self.ENUM_TYPE_TOKENS:
5437                expressions = self._parse_csv(self._parse_equality)
5438            elif is_aggregate:
5439                func_or_ident = self._parse_function(anonymous=True) or self._parse_id_var(
5440                    any_token=False, tokens=(TokenType.VAR, TokenType.ANY)
5441                )
5442                if not func_or_ident:
5443                    return None
5444                expressions = [func_or_ident]
5445                if self._match(TokenType.COMMA):
5446                    expressions.extend(
5447                        self._parse_csv(
5448                            lambda: self._parse_types(
5449                                check_func=check_func,
5450                                schema=schema,
5451                                allow_identifiers=allow_identifiers,
5452                            )
5453                        )
5454                    )
5455            else:
5456                expressions = self._parse_csv(self._parse_type_size)
5457
5458                # https://docs.snowflake.com/en/sql-reference/data-types-vector
5459                if type_token == TokenType.VECTOR and len(expressions) == 2:
5460                    expressions = self._parse_vector_expressions(expressions)
5461
5462            if not self._match(TokenType.R_PAREN):
5463                self._retreat(index)
5464                return None
5465
5466            maybe_func = True
5467
5468        values: t.Optional[t.List[exp.Expression]] = None
5469
5470        if nested and self._match(TokenType.LT):
5471            if is_struct:
5472                expressions = self._parse_csv(lambda: self._parse_struct_types(type_required=True))
5473            else:
5474                expressions = self._parse_csv(
5475                    lambda: self._parse_types(
5476                        check_func=check_func, schema=schema, allow_identifiers=allow_identifiers
5477                    )
5478                )
5479
5480            if not self._match(TokenType.GT):
5481                self.raise_error("Expecting >")
5482
5483            if self._match_set((TokenType.L_BRACKET, TokenType.L_PAREN)):
5484                values = self._parse_csv(self._parse_assignment)
5485                if not values and is_struct:
5486                    values = None
5487                    self._retreat(self._index - 1)
5488                else:
5489                    self._match_set((TokenType.R_BRACKET, TokenType.R_PAREN))
5490
5491        if type_token in self.TIMESTAMPS:
5492            if self._match_text_seq("WITH", "TIME", "ZONE"):
5493                maybe_func = False
5494                tz_type = (
5495                    exp.DataType.Type.TIMETZ
5496                    if type_token in self.TIMES
5497                    else exp.DataType.Type.TIMESTAMPTZ
5498                )
5499                this = exp.DataType(this=tz_type, expressions=expressions)
5500            elif self._match_text_seq("WITH", "LOCAL", "TIME", "ZONE"):
5501                maybe_func = False
5502                this = exp.DataType(this=exp.DataType.Type.TIMESTAMPLTZ, expressions=expressions)
5503            elif self._match_text_seq("WITHOUT", "TIME", "ZONE"):
5504                maybe_func = False
5505        elif type_token == TokenType.INTERVAL:
5506            unit = self._parse_var(upper=True)
5507            if unit:
5508                if self._match_text_seq("TO"):
5509                    unit = exp.IntervalSpan(this=unit, expression=self._parse_var(upper=True))
5510
5511                this = self.expression(exp.DataType, this=self.expression(exp.Interval, unit=unit))
5512            else:
5513                this = self.expression(exp.DataType, this=exp.DataType.Type.INTERVAL)
5514        elif type_token == TokenType.VOID:
5515            this = exp.DataType(this=exp.DataType.Type.NULL)
5516
5517        if maybe_func and check_func:
5518            index2 = self._index
5519            peek = self._parse_string()
5520
5521            if not peek:
5522                self._retreat(index)
5523                return None
5524
5525            self._retreat(index2)
5526
5527        if not this:
5528            if self._match_text_seq("UNSIGNED"):
5529                unsigned_type_token = self.SIGNED_TO_UNSIGNED_TYPE_TOKEN.get(type_token)
5530                if not unsigned_type_token:
5531                    self.raise_error(f"Cannot convert {type_token.value} to unsigned.")
5532
5533                type_token = unsigned_type_token or type_token
5534
5535            # NULLABLE without parentheses can be a column (Presto/Trino)
5536            if type_token == TokenType.NULLABLE and not expressions:
5537                self._retreat(index)
5538                return None
5539
5540            this = exp.DataType(
5541                this=exp.DataType.Type[type_token.value],
5542                expressions=expressions,
5543                nested=nested,
5544                prefix=prefix,
5545            )
5546
5547            # Empty arrays/structs are allowed
5548            if values is not None:
5549                cls = exp.Struct if is_struct else exp.Array
5550                this = exp.cast(cls(expressions=values), this, copy=False)
5551
5552        elif expressions:
5553            this.set("expressions", expressions)
5554
5555        # https://materialize.com/docs/sql/types/list/#type-name
5556        while self._match(TokenType.LIST):
5557            this = exp.DataType(this=exp.DataType.Type.LIST, expressions=[this], nested=True)
5558
5559        index = self._index
5560
5561        # Postgres supports the INT ARRAY[3] syntax as a synonym for INT[3]
5562        matched_array = self._match(TokenType.ARRAY)
5563
5564        while self._curr:
5565            datatype_token = self._prev.token_type
5566            matched_l_bracket = self._match(TokenType.L_BRACKET)
5567
5568            if (not matched_l_bracket and not matched_array) or (
5569                datatype_token == TokenType.ARRAY and self._match(TokenType.R_BRACKET)
5570            ):
5571                # Postgres allows casting empty arrays such as ARRAY[]::INT[],
5572                # not to be confused with the fixed size array parsing
5573                break
5574
5575            matched_array = False
5576            values = self._parse_csv(self._parse_assignment) or None
5577            if (
5578                values
5579                and not schema
5580                and (
5581                    not self.dialect.SUPPORTS_FIXED_SIZE_ARRAYS or datatype_token == TokenType.ARRAY
5582                )
5583            ):
5584                # Retreating here means that we should not parse the following values as part of the data type, e.g. in DuckDB
5585                # ARRAY[1] should retreat and instead be parsed into exp.Array in contrast to INT[x][y] which denotes a fixed-size array data type
5586                self._retreat(index)
5587                break
5588
5589            this = exp.DataType(
5590                this=exp.DataType.Type.ARRAY, expressions=[this], values=values, nested=True
5591            )
5592            self._match(TokenType.R_BRACKET)
5593
5594        if self.TYPE_CONVERTERS and isinstance(this.this, exp.DataType.Type):
5595            converter = self.TYPE_CONVERTERS.get(this.this)
5596            if converter:
5597                this = converter(t.cast(exp.DataType, this))
5598
5599        return this
5600
5601    def _parse_vector_expressions(
5602        self, expressions: t.List[exp.Expression]
5603    ) -> t.List[exp.Expression]:
5604        return [exp.DataType.build(expressions[0].name, dialect=self.dialect), *expressions[1:]]
5605
5606    def _parse_struct_types(self, type_required: bool = False) -> t.Optional[exp.Expression]:
5607        index = self._index
5608
5609        if (
5610            self._curr
5611            and self._next
5612            and self._curr.token_type in self.TYPE_TOKENS
5613            and self._next.token_type in self.TYPE_TOKENS
5614        ):
5615            # Takes care of special cases like `STRUCT<list ARRAY<...>>` where the identifier is also a
5616            # type token. Without this, the list will be parsed as a type and we'll eventually crash
5617            this = self._parse_id_var()
5618        else:
5619            this = (
5620                self._parse_type(parse_interval=False, fallback_to_identifier=True)
5621                or self._parse_id_var()
5622            )
5623
5624        self._match(TokenType.COLON)
5625
5626        if (
5627            type_required
5628            and not isinstance(this, exp.DataType)
5629            and not self._match_set(self.TYPE_TOKENS, advance=False)
5630        ):
5631            self._retreat(index)
5632            return self._parse_types()
5633
5634        return self._parse_column_def(this)
5635
5636    def _parse_at_time_zone(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
5637        if not self._match_text_seq("AT", "TIME", "ZONE"):
5638            return this
5639        return self.expression(exp.AtTimeZone, this=this, zone=self._parse_unary())
5640
5641    def _parse_column(self) -> t.Optional[exp.Expression]:
5642        this = self._parse_column_reference()
5643        column = self._parse_column_ops(this) if this else self._parse_bracket(this)
5644
5645        if self.dialect.SUPPORTS_COLUMN_JOIN_MARKS and column:
5646            column.set("join_mark", self._match(TokenType.JOIN_MARKER))
5647
5648        return column
5649
5650    def _parse_column_reference(self) -> t.Optional[exp.Expression]:
5651        this = self._parse_field()
5652        if (
5653            not this
5654            and self._match(TokenType.VALUES, advance=False)
5655            and self.VALUES_FOLLOWED_BY_PAREN
5656            and (not self._next or self._next.token_type != TokenType.L_PAREN)
5657        ):
5658            this = self._parse_id_var()
5659
5660        if isinstance(this, exp.Identifier):
5661            # We bubble up comments from the Identifier to the Column
5662            this = self.expression(exp.Column, comments=this.pop_comments(), this=this)
5663
5664        return this
5665
5666    def _parse_colon_as_variant_extract(
5667        self, this: t.Optional[exp.Expression]
5668    ) -> t.Optional[exp.Expression]:
5669        casts = []
5670        json_path = []
5671        escape = None
5672
5673        while self._match(TokenType.COLON):
5674            start_index = self._index
5675
5676            # Snowflake allows reserved keywords as json keys but advance_any() excludes TokenType.SELECT from any_tokens=True
5677            path = self._parse_column_ops(
5678                self._parse_field(any_token=True, tokens=(TokenType.SELECT,))
5679            )
5680
5681            # The cast :: operator has a lower precedence than the extraction operator :, so
5682            # we rearrange the AST appropriately to avoid casting the JSON path
5683            while isinstance(path, exp.Cast):
5684                casts.append(path.to)
5685                path = path.this
5686
5687            if casts:
5688                dcolon_offset = next(
5689                    i
5690                    for i, t in enumerate(self._tokens[start_index:])
5691                    if t.token_type == TokenType.DCOLON
5692                )
5693                end_token = self._tokens[start_index + dcolon_offset - 1]
5694            else:
5695                end_token = self._prev
5696
5697            if path:
5698                # Escape single quotes from Snowflake's colon extraction (e.g. col:"a'b") as
5699                # it'll roundtrip to a string literal in GET_PATH
5700                if isinstance(path, exp.Identifier) and path.quoted:
5701                    escape = True
5702
5703                json_path.append(self._find_sql(self._tokens[start_index], end_token))
5704
5705        # The VARIANT extract in Snowflake/Databricks is parsed as a JSONExtract; Snowflake uses the json_path in GET_PATH() while
5706        # Databricks transforms it back to the colon/dot notation
5707        if json_path:
5708            json_path_expr = self.dialect.to_json_path(exp.Literal.string(".".join(json_path)))
5709
5710            if json_path_expr:
5711                json_path_expr.set("escape", escape)
5712
5713            this = self.expression(
5714                exp.JSONExtract,
5715                this=this,
5716                expression=json_path_expr,
5717                variant_extract=True,
5718                requires_json=self.JSON_EXTRACT_REQUIRES_JSON_EXPRESSION,
5719            )
5720
5721            while casts:
5722                this = self.expression(exp.Cast, this=this, to=casts.pop())
5723
5724        return this
5725
5726    def _parse_dcolon(self) -> t.Optional[exp.Expression]:
5727        return self._parse_types()
5728
5729    def _parse_column_ops(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
5730        this = self._parse_bracket(this)
5731
5732        while self._match_set(self.COLUMN_OPERATORS):
5733            op_token = self._prev.token_type
5734            op = self.COLUMN_OPERATORS.get(op_token)
5735
5736            if op_token in self.CAST_COLUMN_OPERATORS:
5737                field = self._parse_dcolon()
5738                if not field:
5739                    self.raise_error("Expected type")
5740            elif op and self._curr:
5741                field = self._parse_column_reference() or self._parse_bitwise()
5742                if isinstance(field, exp.Column) and self._match(TokenType.DOT, advance=False):
5743                    field = self._parse_column_ops(field)
5744            else:
5745                field = self._parse_field(any_token=True, anonymous_func=True)
5746
5747            # Function calls can be qualified, e.g., x.y.FOO()
5748            # This converts the final AST to a series of Dots leading to the function call
5749            # https://cloud.google.com/bigquery/docs/reference/standard-sql/functions-reference#function_call_rules
5750            if isinstance(field, (exp.Func, exp.Window)) and this:
5751                this = this.transform(
5752                    lambda n: n.to_dot(include_dots=False) if isinstance(n, exp.Column) else n
5753                )
5754
5755            if op:
5756                this = op(self, this, field)
5757            elif isinstance(this, exp.Column) and not this.args.get("catalog"):
5758                this = self.expression(
5759                    exp.Column,
5760                    comments=this.comments,
5761                    this=field,
5762                    table=this.this,
5763                    db=this.args.get("table"),
5764                    catalog=this.args.get("db"),
5765                )
5766            elif isinstance(field, exp.Window):
5767                # Move the exp.Dot's to the window's function
5768                window_func = self.expression(exp.Dot, this=this, expression=field.this)
5769                field.set("this", window_func)
5770                this = field
5771            else:
5772                this = self.expression(exp.Dot, this=this, expression=field)
5773
5774            if field and field.comments:
5775                t.cast(exp.Expression, this).add_comments(field.pop_comments())
5776
5777            this = self._parse_bracket(this)
5778
5779        return self._parse_colon_as_variant_extract(this) if self.COLON_IS_VARIANT_EXTRACT else this
5780
5781    def _parse_paren(self) -> t.Optional[exp.Expression]:
5782        if not self._match(TokenType.L_PAREN):
5783            return None
5784
5785        comments = self._prev_comments
5786        query = self._parse_select()
5787
5788        if query:
5789            expressions = [query]
5790        else:
5791            expressions = self._parse_expressions()
5792
5793        this = self._parse_query_modifiers(seq_get(expressions, 0))
5794
5795        if not this and self._match(TokenType.R_PAREN, advance=False):
5796            this = self.expression(exp.Tuple)
5797        elif isinstance(this, exp.UNWRAPPED_QUERIES):
5798            this = self._parse_subquery(this=this, parse_alias=False)
5799        elif isinstance(this, exp.Subquery):
5800            this = self._parse_subquery(this=self._parse_set_operations(this), parse_alias=False)
5801        elif len(expressions) > 1 or self._prev.token_type == TokenType.COMMA:
5802            this = self.expression(exp.Tuple, expressions=expressions)
5803        else:
5804            this = self.expression(exp.Paren, this=this)
5805
5806        if this:
5807            this.add_comments(comments)
5808
5809        self._match_r_paren(expression=this)
5810
5811        if isinstance(this, exp.Paren) and isinstance(this.this, exp.AggFunc):
5812            return self._parse_window(this)
5813
5814        return this
5815
5816    def _parse_primary(self) -> t.Optional[exp.Expression]:
5817        if self._match_set(self.PRIMARY_PARSERS):
5818            token_type = self._prev.token_type
5819            primary = self.PRIMARY_PARSERS[token_type](self, self._prev)
5820
5821            if token_type == TokenType.STRING:
5822                expressions = [primary]
5823                while self._match(TokenType.STRING):
5824                    expressions.append(exp.Literal.string(self._prev.text))
5825
5826                if len(expressions) > 1:
5827                    return self.expression(exp.Concat, expressions=expressions)
5828
5829            return primary
5830
5831        if self._match_pair(TokenType.DOT, TokenType.NUMBER):
5832            return exp.Literal.number(f"0.{self._prev.text}")
5833
5834        return self._parse_paren()
5835
5836    def _parse_field(
5837        self,
5838        any_token: bool = False,
5839        tokens: t.Optional[t.Collection[TokenType]] = None,
5840        anonymous_func: bool = False,
5841    ) -> t.Optional[exp.Expression]:
5842        if anonymous_func:
5843            field = (
5844                self._parse_function(anonymous=anonymous_func, any_token=any_token)
5845                or self._parse_primary()
5846            )
5847        else:
5848            field = self._parse_primary() or self._parse_function(
5849                anonymous=anonymous_func, any_token=any_token
5850            )
5851        return field or self._parse_id_var(any_token=any_token, tokens=tokens)
5852
5853    def _parse_function(
5854        self,
5855        functions: t.Optional[t.Dict[str, t.Callable]] = None,
5856        anonymous: bool = False,
5857        optional_parens: bool = True,
5858        any_token: bool = False,
5859    ) -> t.Optional[exp.Expression]:
5860        # This allows us to also parse {fn <function>} syntax (Snowflake, MySQL support this)
5861        # See: https://community.snowflake.com/s/article/SQL-Escape-Sequences
5862        fn_syntax = False
5863        if (
5864            self._match(TokenType.L_BRACE, advance=False)
5865            and self._next
5866            and self._next.text.upper() == "FN"
5867        ):
5868            self._advance(2)
5869            fn_syntax = True
5870
5871        func = self._parse_function_call(
5872            functions=functions,
5873            anonymous=anonymous,
5874            optional_parens=optional_parens,
5875            any_token=any_token,
5876        )
5877
5878        if fn_syntax:
5879            self._match(TokenType.R_BRACE)
5880
5881        return func
5882
5883    def _parse_function_args(self, alias: bool = False) -> t.List[exp.Expression]:
5884        return self._parse_csv(lambda: self._parse_lambda(alias=alias))
5885
5886    def _parse_function_call(
5887        self,
5888        functions: t.Optional[t.Dict[str, t.Callable]] = None,
5889        anonymous: bool = False,
5890        optional_parens: bool = True,
5891        any_token: bool = False,
5892    ) -> t.Optional[exp.Expression]:
5893        if not self._curr:
5894            return None
5895
5896        comments = self._curr.comments
5897        prev = self._prev
5898        token = self._curr
5899        token_type = self._curr.token_type
5900        this = self._curr.text
5901        upper = this.upper()
5902
5903        parser = self.NO_PAREN_FUNCTION_PARSERS.get(upper)
5904        if optional_parens and parser and token_type not in self.INVALID_FUNC_NAME_TOKENS:
5905            self._advance()
5906            return self._parse_window(parser(self))
5907
5908        if not self._next or self._next.token_type != TokenType.L_PAREN:
5909            if optional_parens and token_type in self.NO_PAREN_FUNCTIONS:
5910                self._advance()
5911                return self.expression(self.NO_PAREN_FUNCTIONS[token_type])
5912
5913            return None
5914
5915        if any_token:
5916            if token_type in self.RESERVED_TOKENS:
5917                return None
5918        elif token_type not in self.FUNC_TOKENS:
5919            return None
5920
5921        self._advance(2)
5922
5923        parser = self.FUNCTION_PARSERS.get(upper)
5924        if parser and not anonymous:
5925            this = parser(self)
5926        else:
5927            subquery_predicate = self.SUBQUERY_PREDICATES.get(token_type)
5928
5929            if subquery_predicate:
5930                expr = None
5931                if self._curr.token_type in (TokenType.SELECT, TokenType.WITH):
5932                    expr = self._parse_select()
5933                    self._match_r_paren()
5934                elif prev and prev.token_type in (TokenType.LIKE, TokenType.ILIKE):
5935                    # Backtrack one token since we've consumed the L_PAREN here. Instead, we'd like
5936                    # to parse "LIKE [ANY | ALL] (...)" as a whole into an exp.Tuple or exp.Paren
5937                    self._advance(-1)
5938                    expr = self._parse_bitwise()
5939
5940                if expr:
5941                    return self.expression(subquery_predicate, comments=comments, this=expr)
5942
5943            if functions is None:
5944                functions = self.FUNCTIONS
5945
5946            function = functions.get(upper)
5947            known_function = function and not anonymous
5948
5949            alias = not known_function or upper in self.FUNCTIONS_WITH_ALIASED_ARGS
5950            args = self._parse_function_args(alias)
5951
5952            post_func_comments = self._curr and self._curr.comments
5953            if known_function and post_func_comments:
5954                # If the user-inputted comment "/* sqlglot.anonymous */" is following the function
5955                # call we'll construct it as exp.Anonymous, even if it's "known"
5956                if any(
5957                    comment.lstrip().startswith(exp.SQLGLOT_ANONYMOUS)
5958                    for comment in post_func_comments
5959                ):
5960                    known_function = False
5961
5962            if alias and known_function:
5963                args = self._kv_to_prop_eq(args)
5964
5965            if known_function:
5966                func_builder = t.cast(t.Callable, function)
5967
5968                if "dialect" in func_builder.__code__.co_varnames:
5969                    func = func_builder(args, dialect=self.dialect)
5970                else:
5971                    func = func_builder(args)
5972
5973                func = self.validate_expression(func, args)
5974                if self.dialect.PRESERVE_ORIGINAL_NAMES:
5975                    func.meta["name"] = this
5976
5977                this = func
5978            else:
5979                if token_type == TokenType.IDENTIFIER:
5980                    this = exp.Identifier(this=this, quoted=True).update_positions(token)
5981
5982                this = self.expression(exp.Anonymous, this=this, expressions=args)
5983                this = this.update_positions(token)
5984
5985        if isinstance(this, exp.Expression):
5986            this.add_comments(comments)
5987
5988        self._match_r_paren(this)
5989        return self._parse_window(this)
5990
5991    def _to_prop_eq(self, expression: exp.Expression, index: int) -> exp.Expression:
5992        return expression
5993
5994    def _kv_to_prop_eq(
5995        self, expressions: t.List[exp.Expression], parse_map: bool = False
5996    ) -> t.List[exp.Expression]:
5997        transformed = []
5998
5999        for index, e in enumerate(expressions):
6000            if isinstance(e, self.KEY_VALUE_DEFINITIONS):
6001                if isinstance(e, exp.Alias):
6002                    e = self.expression(exp.PropertyEQ, this=e.args.get("alias"), expression=e.this)
6003
6004                if not isinstance(e, exp.PropertyEQ):
6005                    e = self.expression(
6006                        exp.PropertyEQ,
6007                        this=e.this if parse_map else exp.to_identifier(e.this.name),
6008                        expression=e.expression,
6009                    )
6010
6011                if isinstance(e.this, exp.Column):
6012                    e.this.replace(e.this.this)
6013            else:
6014                e = self._to_prop_eq(e, index)
6015
6016            transformed.append(e)
6017
6018        return transformed
6019
6020    def _parse_user_defined_function_expression(self) -> t.Optional[exp.Expression]:
6021        return self._parse_statement()
6022
6023    def _parse_function_parameter(self) -> t.Optional[exp.Expression]:
6024        return self._parse_column_def(this=self._parse_id_var(), computed_column=False)
6025
6026    def _parse_user_defined_function(
6027        self, kind: t.Optional[TokenType] = None
6028    ) -> t.Optional[exp.Expression]:
6029        this = self._parse_table_parts(schema=True)
6030
6031        if not self._match(TokenType.L_PAREN):
6032            return this
6033
6034        expressions = self._parse_csv(self._parse_function_parameter)
6035        self._match_r_paren()
6036        return self.expression(
6037            exp.UserDefinedFunction, this=this, expressions=expressions, wrapped=True
6038        )
6039
6040    def _parse_introducer(self, token: Token) -> exp.Introducer | exp.Identifier:
6041        literal = self._parse_primary()
6042        if literal:
6043            return self.expression(exp.Introducer, this=token.text, expression=literal)
6044
6045        return self._identifier_expression(token)
6046
6047    def _parse_session_parameter(self) -> exp.SessionParameter:
6048        kind = None
6049        this = self._parse_id_var() or self._parse_primary()
6050
6051        if this and self._match(TokenType.DOT):
6052            kind = this.name
6053            this = self._parse_var() or self._parse_primary()
6054
6055        return self.expression(exp.SessionParameter, this=this, kind=kind)
6056
6057    def _parse_lambda_arg(self) -> t.Optional[exp.Expression]:
6058        return self._parse_id_var()
6059
6060    def _parse_lambda(self, alias: bool = False) -> t.Optional[exp.Expression]:
6061        index = self._index
6062
6063        if self._match(TokenType.L_PAREN):
6064            expressions = t.cast(
6065                t.List[t.Optional[exp.Expression]], self._parse_csv(self._parse_lambda_arg)
6066            )
6067
6068            if not self._match(TokenType.R_PAREN):
6069                self._retreat(index)
6070        else:
6071            expressions = [self._parse_lambda_arg()]
6072
6073        if self._match_set(self.LAMBDAS):
6074            return self.LAMBDAS[self._prev.token_type](self, expressions)
6075
6076        self._retreat(index)
6077
6078        this: t.Optional[exp.Expression]
6079
6080        if self._match(TokenType.DISTINCT):
6081            this = self.expression(
6082                exp.Distinct, expressions=self._parse_csv(self._parse_assignment)
6083            )
6084        else:
6085            this = self._parse_select_or_expression(alias=alias)
6086
6087        return self._parse_limit(
6088            self._parse_order(self._parse_having_max(self._parse_respect_or_ignore_nulls(this)))
6089        )
6090
6091    def _parse_schema(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
6092        index = self._index
6093        if not self._match(TokenType.L_PAREN):
6094            return this
6095
6096        # Disambiguate between schema and subquery/CTE, e.g. in INSERT INTO table (<expr>),
6097        # expr can be of both types
6098        if self._match_set(self.SELECT_START_TOKENS):
6099            self._retreat(index)
6100            return this
6101        args = self._parse_csv(lambda: self._parse_constraint() or self._parse_field_def())
6102        self._match_r_paren()
6103        return self.expression(exp.Schema, this=this, expressions=args)
6104
6105    def _parse_field_def(self) -> t.Optional[exp.Expression]:
6106        return self._parse_column_def(self._parse_field(any_token=True))
6107
6108    def _parse_column_def(
6109        self, this: t.Optional[exp.Expression], computed_column: bool = True
6110    ) -> t.Optional[exp.Expression]:
6111        # column defs are not really columns, they're identifiers
6112        if isinstance(this, exp.Column):
6113            this = this.this
6114
6115        if not computed_column:
6116            self._match(TokenType.ALIAS)
6117
6118        kind = self._parse_types(schema=True)
6119
6120        if self._match_text_seq("FOR", "ORDINALITY"):
6121            return self.expression(exp.ColumnDef, this=this, ordinality=True)
6122
6123        constraints: t.List[exp.Expression] = []
6124
6125        if (not kind and self._match(TokenType.ALIAS)) or self._match_texts(
6126            ("ALIAS", "MATERIALIZED")
6127        ):
6128            persisted = self._prev.text.upper() == "MATERIALIZED"
6129            constraint_kind = exp.ComputedColumnConstraint(
6130                this=self._parse_assignment(),
6131                persisted=persisted or self._match_text_seq("PERSISTED"),
6132                data_type=exp.Var(this="AUTO")
6133                if self._match_text_seq("AUTO")
6134                else self._parse_types(),
6135                not_null=self._match_pair(TokenType.NOT, TokenType.NULL),
6136            )
6137            constraints.append(self.expression(exp.ColumnConstraint, kind=constraint_kind))
6138        elif (
6139            kind
6140            and self._match(TokenType.ALIAS, advance=False)
6141            and (
6142                not self.WRAPPED_TRANSFORM_COLUMN_CONSTRAINT
6143                or (self._next and self._next.token_type == TokenType.L_PAREN)
6144            )
6145        ):
6146            self._advance()
6147            constraints.append(
6148                self.expression(
6149                    exp.ColumnConstraint,
6150                    kind=exp.ComputedColumnConstraint(
6151                        this=self._parse_disjunction(),
6152                        persisted=self._match_texts(("STORED", "VIRTUAL"))
6153                        and self._prev.text.upper() == "STORED",
6154                    ),
6155                )
6156            )
6157
6158        while True:
6159            constraint = self._parse_column_constraint()
6160            if not constraint:
6161                break
6162            constraints.append(constraint)
6163
6164        if not kind and not constraints:
6165            return this
6166
6167        return self.expression(exp.ColumnDef, this=this, kind=kind, constraints=constraints)
6168
6169    def _parse_auto_increment(
6170        self,
6171    ) -> exp.GeneratedAsIdentityColumnConstraint | exp.AutoIncrementColumnConstraint:
6172        start = None
6173        increment = None
6174        order = None
6175
6176        if self._match(TokenType.L_PAREN, advance=False):
6177            args = self._parse_wrapped_csv(self._parse_bitwise)
6178            start = seq_get(args, 0)
6179            increment = seq_get(args, 1)
6180        elif self._match_text_seq("START"):
6181            start = self._parse_bitwise()
6182            self._match_text_seq("INCREMENT")
6183            increment = self._parse_bitwise()
6184            if self._match_text_seq("ORDER"):
6185                order = True
6186            elif self._match_text_seq("NOORDER"):
6187                order = False
6188
6189        if start and increment:
6190            return exp.GeneratedAsIdentityColumnConstraint(
6191                start=start, increment=increment, this=False, order=order
6192            )
6193
6194        return exp.AutoIncrementColumnConstraint()
6195
6196    def _parse_auto_property(self) -> t.Optional[exp.AutoRefreshProperty]:
6197        if not self._match_text_seq("REFRESH"):
6198            self._retreat(self._index - 1)
6199            return None
6200        return self.expression(exp.AutoRefreshProperty, this=self._parse_var(upper=True))
6201
6202    def _parse_compress(self) -> exp.CompressColumnConstraint:
6203        if self._match(TokenType.L_PAREN, advance=False):
6204            return self.expression(
6205                exp.CompressColumnConstraint, this=self._parse_wrapped_csv(self._parse_bitwise)
6206            )
6207
6208        return self.expression(exp.CompressColumnConstraint, this=self._parse_bitwise())
6209
6210    def _parse_generated_as_identity(
6211        self,
6212    ) -> (
6213        exp.GeneratedAsIdentityColumnConstraint
6214        | exp.ComputedColumnConstraint
6215        | exp.GeneratedAsRowColumnConstraint
6216    ):
6217        if self._match_text_seq("BY", "DEFAULT"):
6218            on_null = self._match_pair(TokenType.ON, TokenType.NULL)
6219            this = self.expression(
6220                exp.GeneratedAsIdentityColumnConstraint, this=False, on_null=on_null
6221            )
6222        else:
6223            self._match_text_seq("ALWAYS")
6224            this = self.expression(exp.GeneratedAsIdentityColumnConstraint, this=True)
6225
6226        self._match(TokenType.ALIAS)
6227
6228        if self._match_text_seq("ROW"):
6229            start = self._match_text_seq("START")
6230            if not start:
6231                self._match(TokenType.END)
6232            hidden = self._match_text_seq("HIDDEN")
6233            return self.expression(exp.GeneratedAsRowColumnConstraint, start=start, hidden=hidden)
6234
6235        identity = self._match_text_seq("IDENTITY")
6236
6237        if self._match(TokenType.L_PAREN):
6238            if self._match(TokenType.START_WITH):
6239                this.set("start", self._parse_bitwise())
6240            if self._match_text_seq("INCREMENT", "BY"):
6241                this.set("increment", self._parse_bitwise())
6242            if self._match_text_seq("MINVALUE"):
6243                this.set("minvalue", self._parse_bitwise())
6244            if self._match_text_seq("MAXVALUE"):
6245                this.set("maxvalue", self._parse_bitwise())
6246
6247            if self._match_text_seq("CYCLE"):
6248                this.set("cycle", True)
6249            elif self._match_text_seq("NO", "CYCLE"):
6250                this.set("cycle", False)
6251
6252            if not identity:
6253                this.set("expression", self._parse_range())
6254            elif not this.args.get("start") and self._match(TokenType.NUMBER, advance=False):
6255                args = self._parse_csv(self._parse_bitwise)
6256                this.set("start", seq_get(args, 0))
6257                this.set("increment", seq_get(args, 1))
6258
6259            self._match_r_paren()
6260
6261        return this
6262
6263    def _parse_inline(self) -> exp.InlineLengthColumnConstraint:
6264        self._match_text_seq("LENGTH")
6265        return self.expression(exp.InlineLengthColumnConstraint, this=self._parse_bitwise())
6266
6267    def _parse_not_constraint(self) -> t.Optional[exp.Expression]:
6268        if self._match_text_seq("NULL"):
6269            return self.expression(exp.NotNullColumnConstraint)
6270        if self._match_text_seq("CASESPECIFIC"):
6271            return self.expression(exp.CaseSpecificColumnConstraint, not_=True)
6272        if self._match_text_seq("FOR", "REPLICATION"):
6273            return self.expression(exp.NotForReplicationColumnConstraint)
6274
6275        # Unconsume the `NOT` token
6276        self._retreat(self._index - 1)
6277        return None
6278
6279    def _parse_column_constraint(self) -> t.Optional[exp.Expression]:
6280        this = self._match(TokenType.CONSTRAINT) and self._parse_id_var()
6281
6282        procedure_option_follows = (
6283            self._match(TokenType.WITH, advance=False)
6284            and self._next
6285            and self._next.text.upper() in self.PROCEDURE_OPTIONS
6286        )
6287
6288        if not procedure_option_follows and self._match_texts(self.CONSTRAINT_PARSERS):
6289            return self.expression(
6290                exp.ColumnConstraint,
6291                this=this,
6292                kind=self.CONSTRAINT_PARSERS[self._prev.text.upper()](self),
6293            )
6294
6295        return this
6296
6297    def _parse_constraint(self) -> t.Optional[exp.Expression]:
6298        if not self._match(TokenType.CONSTRAINT):
6299            return self._parse_unnamed_constraint(constraints=self.SCHEMA_UNNAMED_CONSTRAINTS)
6300
6301        return self.expression(
6302            exp.Constraint,
6303            this=self._parse_id_var(),
6304            expressions=self._parse_unnamed_constraints(),
6305        )
6306
6307    def _parse_unnamed_constraints(self) -> t.List[exp.Expression]:
6308        constraints = []
6309        while True:
6310            constraint = self._parse_unnamed_constraint() or self._parse_function()
6311            if not constraint:
6312                break
6313            constraints.append(constraint)
6314
6315        return constraints
6316
6317    def _parse_unnamed_constraint(
6318        self, constraints: t.Optional[t.Collection[str]] = None
6319    ) -> t.Optional[exp.Expression]:
6320        if self._match(TokenType.IDENTIFIER, advance=False) or not self._match_texts(
6321            constraints or self.CONSTRAINT_PARSERS
6322        ):
6323            return None
6324
6325        constraint = self._prev.text.upper()
6326        if constraint not in self.CONSTRAINT_PARSERS:
6327            self.raise_error(f"No parser found for schema constraint {constraint}.")
6328
6329        return self.CONSTRAINT_PARSERS[constraint](self)
6330
6331    def _parse_unique_key(self) -> t.Optional[exp.Expression]:
6332        return self._parse_id_var(any_token=False)
6333
6334    def _parse_unique(self) -> exp.UniqueColumnConstraint:
6335        self._match_texts(("KEY", "INDEX"))
6336        return self.expression(
6337            exp.UniqueColumnConstraint,
6338            nulls=self._match_text_seq("NULLS", "NOT", "DISTINCT"),
6339            this=self._parse_schema(self._parse_unique_key()),
6340            index_type=self._match(TokenType.USING) and self._advance_any() and self._prev.text,
6341            on_conflict=self._parse_on_conflict(),
6342            options=self._parse_key_constraint_options(),
6343        )
6344
6345    def _parse_key_constraint_options(self) -> t.List[str]:
6346        options = []
6347        while True:
6348            if not self._curr:
6349                break
6350
6351            if self._match(TokenType.ON):
6352                action = None
6353                on = self._advance_any() and self._prev.text
6354
6355                if self._match_text_seq("NO", "ACTION"):
6356                    action = "NO ACTION"
6357                elif self._match_text_seq("CASCADE"):
6358                    action = "CASCADE"
6359                elif self._match_text_seq("RESTRICT"):
6360                    action = "RESTRICT"
6361                elif self._match_pair(TokenType.SET, TokenType.NULL):
6362                    action = "SET NULL"
6363                elif self._match_pair(TokenType.SET, TokenType.DEFAULT):
6364                    action = "SET DEFAULT"
6365                else:
6366                    self.raise_error("Invalid key constraint")
6367
6368                options.append(f"ON {on} {action}")
6369            else:
6370                var = self._parse_var_from_options(
6371                    self.KEY_CONSTRAINT_OPTIONS, raise_unmatched=False
6372                )
6373                if not var:
6374                    break
6375                options.append(var.name)
6376
6377        return options
6378
6379    def _parse_references(self, match: bool = True) -> t.Optional[exp.Reference]:
6380        if match and not self._match(TokenType.REFERENCES):
6381            return None
6382
6383        expressions = None
6384        this = self._parse_table(schema=True)
6385        options = self._parse_key_constraint_options()
6386        return self.expression(exp.Reference, this=this, expressions=expressions, options=options)
6387
6388    def _parse_foreign_key(self) -> exp.ForeignKey:
6389        expressions = (
6390            self._parse_wrapped_id_vars()
6391            if not self._match(TokenType.REFERENCES, advance=False)
6392            else None
6393        )
6394        reference = self._parse_references()
6395        on_options = {}
6396
6397        while self._match(TokenType.ON):
6398            if not self._match_set((TokenType.DELETE, TokenType.UPDATE)):
6399                self.raise_error("Expected DELETE or UPDATE")
6400
6401            kind = self._prev.text.lower()
6402
6403            if self._match_text_seq("NO", "ACTION"):
6404                action = "NO ACTION"
6405            elif self._match(TokenType.SET):
6406                self._match_set((TokenType.NULL, TokenType.DEFAULT))
6407                action = "SET " + self._prev.text.upper()
6408            else:
6409                self._advance()
6410                action = self._prev.text.upper()
6411
6412            on_options[kind] = action
6413
6414        return self.expression(
6415            exp.ForeignKey,
6416            expressions=expressions,
6417            reference=reference,
6418            options=self._parse_key_constraint_options(),
6419            **on_options,  # type: ignore
6420        )
6421
6422    def _parse_primary_key_part(self) -> t.Optional[exp.Expression]:
6423        return self._parse_ordered() or self._parse_field()
6424
6425    def _parse_period_for_system_time(self) -> t.Optional[exp.PeriodForSystemTimeConstraint]:
6426        if not self._match(TokenType.TIMESTAMP_SNAPSHOT):
6427            self._retreat(self._index - 1)
6428            return None
6429
6430        id_vars = self._parse_wrapped_id_vars()
6431        return self.expression(
6432            exp.PeriodForSystemTimeConstraint,
6433            this=seq_get(id_vars, 0),
6434            expression=seq_get(id_vars, 1),
6435        )
6436
6437    def _parse_primary_key(
6438        self, wrapped_optional: bool = False, in_props: bool = False
6439    ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey:
6440        desc = (
6441            self._match_set((TokenType.ASC, TokenType.DESC))
6442            and self._prev.token_type == TokenType.DESC
6443        )
6444
6445        if not in_props and not self._match(TokenType.L_PAREN, advance=False):
6446            return self.expression(
6447                exp.PrimaryKeyColumnConstraint,
6448                desc=desc,
6449                options=self._parse_key_constraint_options(),
6450            )
6451
6452        expressions = self._parse_wrapped_csv(
6453            self._parse_primary_key_part, optional=wrapped_optional
6454        )
6455
6456        return self.expression(
6457            exp.PrimaryKey,
6458            expressions=expressions,
6459            include=self._parse_index_params(),
6460            options=self._parse_key_constraint_options(),
6461        )
6462
6463    def _parse_bracket_key_value(self, is_map: bool = False) -> t.Optional[exp.Expression]:
6464        return self._parse_slice(self._parse_alias(self._parse_assignment(), explicit=True))
6465
6466    def _parse_odbc_datetime_literal(self) -> exp.Expression:
6467        """
6468        Parses a datetime column in ODBC format. We parse the column into the corresponding
6469        types, for example `{d'yyyy-mm-dd'}` will be parsed as a `Date` column, exactly the
6470        same as we did for `DATE('yyyy-mm-dd')`.
6471
6472        Reference:
6473        https://learn.microsoft.com/en-us/sql/odbc/reference/develop-app/date-time-and-timestamp-literals
6474        """
6475        self._match(TokenType.VAR)
6476        exp_class = self.ODBC_DATETIME_LITERALS[self._prev.text.lower()]
6477        expression = self.expression(exp_class=exp_class, this=self._parse_string())
6478        if not self._match(TokenType.R_BRACE):
6479            self.raise_error("Expected }")
6480        return expression
6481
6482    def _parse_bracket(self, this: t.Optional[exp.Expression] = None) -> t.Optional[exp.Expression]:
6483        if not self._match_set((TokenType.L_BRACKET, TokenType.L_BRACE)):
6484            return this
6485
6486        if self.MAP_KEYS_ARE_ARBITRARY_EXPRESSIONS:
6487            map_token = seq_get(self._tokens, self._index - 2)
6488            parse_map = map_token is not None and map_token.text.upper() == "MAP"
6489        else:
6490            parse_map = False
6491
6492        bracket_kind = self._prev.token_type
6493        if (
6494            bracket_kind == TokenType.L_BRACE
6495            and self._curr
6496            and self._curr.token_type == TokenType.VAR
6497            and self._curr.text.lower() in self.ODBC_DATETIME_LITERALS
6498        ):
6499            return self._parse_odbc_datetime_literal()
6500
6501        expressions = self._parse_csv(
6502            lambda: self._parse_bracket_key_value(is_map=bracket_kind == TokenType.L_BRACE)
6503        )
6504
6505        if bracket_kind == TokenType.L_BRACKET and not self._match(TokenType.R_BRACKET):
6506            self.raise_error("Expected ]")
6507        elif bracket_kind == TokenType.L_BRACE and not self._match(TokenType.R_BRACE):
6508            self.raise_error("Expected }")
6509
6510        # https://duckdb.org/docs/sql/data_types/struct.html#creating-structs
6511        if bracket_kind == TokenType.L_BRACE:
6512            this = self.expression(
6513                exp.Struct,
6514                expressions=self._kv_to_prop_eq(expressions=expressions, parse_map=parse_map),
6515            )
6516        elif not this:
6517            this = build_array_constructor(
6518                exp.Array, args=expressions, bracket_kind=bracket_kind, dialect=self.dialect
6519            )
6520        else:
6521            constructor_type = self.ARRAY_CONSTRUCTORS.get(this.name.upper())
6522            if constructor_type:
6523                return build_array_constructor(
6524                    constructor_type,
6525                    args=expressions,
6526                    bracket_kind=bracket_kind,
6527                    dialect=self.dialect,
6528                )
6529
6530            expressions = apply_index_offset(
6531                this, expressions, -self.dialect.INDEX_OFFSET, dialect=self.dialect
6532            )
6533            this = self.expression(
6534                exp.Bracket,
6535                this=this,
6536                expressions=expressions,
6537                comments=this.pop_comments(),
6538            )
6539
6540        self._add_comments(this)
6541        return self._parse_bracket(this)
6542
6543    def _parse_slice(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
6544        if self._match(TokenType.COLON):
6545            return self.expression(exp.Slice, this=this, expression=self._parse_assignment())
6546        return this
6547
6548    def _parse_case(self) -> t.Optional[exp.Expression]:
6549        if self._match(TokenType.DOT, advance=False):
6550            # Avoid raising on valid expressions like case.*, supported by, e.g., spark & snowflake
6551            self._retreat(self._index - 1)
6552            return None
6553
6554        ifs = []
6555        default = None
6556
6557        comments = self._prev_comments
6558        expression = self._parse_assignment()
6559
6560        while self._match(TokenType.WHEN):
6561            this = self._parse_assignment()
6562            self._match(TokenType.THEN)
6563            then = self._parse_assignment()
6564            ifs.append(self.expression(exp.If, this=this, true=then))
6565
6566        if self._match(TokenType.ELSE):
6567            default = self._parse_assignment()
6568
6569        if not self._match(TokenType.END):
6570            if isinstance(default, exp.Interval) and default.this.sql().upper() == "END":
6571                default = exp.column("interval")
6572            else:
6573                self.raise_error("Expected END after CASE", self._prev)
6574
6575        return self.expression(
6576            exp.Case, comments=comments, this=expression, ifs=ifs, default=default
6577        )
6578
6579    def _parse_if(self) -> t.Optional[exp.Expression]:
6580        if self._match(TokenType.L_PAREN):
6581            args = self._parse_csv(
6582                lambda: self._parse_alias(self._parse_assignment(), explicit=True)
6583            )
6584            this = self.validate_expression(exp.If.from_arg_list(args), args)
6585            self._match_r_paren()
6586        else:
6587            index = self._index - 1
6588
6589            if self.NO_PAREN_IF_COMMANDS and index == 0:
6590                return self._parse_as_command(self._prev)
6591
6592            condition = self._parse_assignment()
6593
6594            if not condition:
6595                self._retreat(index)
6596                return None
6597
6598            self._match(TokenType.THEN)
6599            true = self._parse_assignment()
6600            false = self._parse_assignment() if self._match(TokenType.ELSE) else None
6601            self._match(TokenType.END)
6602            this = self.expression(exp.If, this=condition, true=true, false=false)
6603
6604        return this
6605
6606    def _parse_next_value_for(self) -> t.Optional[exp.Expression]:
6607        if not self._match_text_seq("VALUE", "FOR"):
6608            self._retreat(self._index - 1)
6609            return None
6610
6611        return self.expression(
6612            exp.NextValueFor,
6613            this=self._parse_column(),
6614            order=self._match(TokenType.OVER) and self._parse_wrapped(self._parse_order),
6615        )
6616
6617    def _parse_extract(self) -> exp.Extract | exp.Anonymous:
6618        this = self._parse_function() or self._parse_var_or_string(upper=True)
6619
6620        if self._match(TokenType.FROM):
6621            return self.expression(exp.Extract, this=this, expression=self._parse_bitwise())
6622
6623        if not self._match(TokenType.COMMA):
6624            self.raise_error("Expected FROM or comma after EXTRACT", self._prev)
6625
6626        return self.expression(exp.Extract, this=this, expression=self._parse_bitwise())
6627
6628    def _parse_gap_fill(self) -> exp.GapFill:
6629        self._match(TokenType.TABLE)
6630        this = self._parse_table()
6631
6632        self._match(TokenType.COMMA)
6633        args = [this, *self._parse_csv(self._parse_lambda)]
6634
6635        gap_fill = exp.GapFill.from_arg_list(args)
6636        return self.validate_expression(gap_fill, args)
6637
6638    def _parse_cast(self, strict: bool, safe: t.Optional[bool] = None) -> exp.Expression:
6639        this = self._parse_assignment()
6640
6641        if not self._match(TokenType.ALIAS):
6642            if self._match(TokenType.COMMA):
6643                return self.expression(exp.CastToStrType, this=this, to=self._parse_string())
6644
6645            self.raise_error("Expected AS after CAST")
6646
6647        fmt = None
6648        to = self._parse_types()
6649
6650        default = self._match(TokenType.DEFAULT)
6651        if default:
6652            default = self._parse_bitwise()
6653            self._match_text_seq("ON", "CONVERSION", "ERROR")
6654
6655        if self._match_set((TokenType.FORMAT, TokenType.COMMA)):
6656            fmt_string = self._parse_string()
6657            fmt = self._parse_at_time_zone(fmt_string)
6658
6659            if not to:
6660                to = exp.DataType.build(exp.DataType.Type.UNKNOWN)
6661            if to.this in exp.DataType.TEMPORAL_TYPES:
6662                this = self.expression(
6663                    exp.StrToDate if to.this == exp.DataType.Type.DATE else exp.StrToTime,
6664                    this=this,
6665                    format=exp.Literal.string(
6666                        format_time(
6667                            fmt_string.this if fmt_string else "",
6668                            self.dialect.FORMAT_MAPPING or self.dialect.TIME_MAPPING,
6669                            self.dialect.FORMAT_TRIE or self.dialect.TIME_TRIE,
6670                        )
6671                    ),
6672                    safe=safe,
6673                )
6674
6675                if isinstance(fmt, exp.AtTimeZone) and isinstance(this, exp.StrToTime):
6676                    this.set("zone", fmt.args["zone"])
6677                return this
6678        elif not to:
6679            self.raise_error("Expected TYPE after CAST")
6680        elif isinstance(to, exp.Identifier):
6681            to = exp.DataType.build(to.name, dialect=self.dialect, udt=True)
6682        elif to.this == exp.DataType.Type.CHAR:
6683            if self._match(TokenType.CHARACTER_SET):
6684                to = self.expression(exp.CharacterSet, this=self._parse_var_or_string())
6685
6686        return self.build_cast(
6687            strict=strict,
6688            this=this,
6689            to=to,
6690            format=fmt,
6691            safe=safe,
6692            action=self._parse_var_from_options(self.CAST_ACTIONS, raise_unmatched=False),
6693            default=default,
6694        )
6695
6696    def _parse_string_agg(self) -> exp.GroupConcat:
6697        if self._match(TokenType.DISTINCT):
6698            args: t.List[t.Optional[exp.Expression]] = [
6699                self.expression(exp.Distinct, expressions=[self._parse_assignment()])
6700            ]
6701            if self._match(TokenType.COMMA):
6702                args.extend(self._parse_csv(self._parse_assignment))
6703        else:
6704            args = self._parse_csv(self._parse_assignment)  # type: ignore
6705
6706        if self._match_text_seq("ON", "OVERFLOW"):
6707            # trino: LISTAGG(expression [, separator] [ON OVERFLOW overflow_behavior])
6708            if self._match_text_seq("ERROR"):
6709                on_overflow: t.Optional[exp.Expression] = exp.var("ERROR")
6710            else:
6711                self._match_text_seq("TRUNCATE")
6712                on_overflow = self.expression(
6713                    exp.OverflowTruncateBehavior,
6714                    this=self._parse_string(),
6715                    with_count=(
6716                        self._match_text_seq("WITH", "COUNT")
6717                        or not self._match_text_seq("WITHOUT", "COUNT")
6718                    ),
6719                )
6720        else:
6721            on_overflow = None
6722
6723        index = self._index
6724        if not self._match(TokenType.R_PAREN) and args:
6725            # postgres: STRING_AGG([DISTINCT] expression, separator [ORDER BY expression1 {ASC | DESC} [, ...]])
6726            # bigquery: STRING_AGG([DISTINCT] expression [, separator] [ORDER BY key [{ASC | DESC}] [, ... ]] [LIMIT n])
6727            # The order is parsed through `this` as a canonicalization for WITHIN GROUPs
6728            args[0] = self._parse_limit(this=self._parse_order(this=args[0]))
6729            return self.expression(exp.GroupConcat, this=args[0], separator=seq_get(args, 1))
6730
6731        # Checks if we can parse an order clause: WITHIN GROUP (ORDER BY <order_by_expression_list> [ASC | DESC]).
6732        # This is done "manually", instead of letting _parse_window parse it into an exp.WithinGroup node, so that
6733        # the STRING_AGG call is parsed like in MySQL / SQLite and can thus be transpiled more easily to them.
6734        if not self._match_text_seq("WITHIN", "GROUP"):
6735            self._retreat(index)
6736            return self.validate_expression(exp.GroupConcat.from_arg_list(args), args)
6737
6738        # The corresponding match_r_paren will be called in parse_function (caller)
6739        self._match_l_paren()
6740
6741        return self.expression(
6742            exp.GroupConcat,
6743            this=self._parse_order(this=seq_get(args, 0)),
6744            separator=seq_get(args, 1),
6745            on_overflow=on_overflow,
6746        )
6747
6748    def _parse_convert(
6749        self, strict: bool, safe: t.Optional[bool] = None
6750    ) -> t.Optional[exp.Expression]:
6751        this = self._parse_bitwise()
6752
6753        if self._match(TokenType.USING):
6754            to: t.Optional[exp.Expression] = self.expression(
6755                exp.CharacterSet, this=self._parse_var()
6756            )
6757        elif self._match(TokenType.COMMA):
6758            to = self._parse_types()
6759        else:
6760            to = None
6761
6762        return self.build_cast(strict=strict, this=this, to=to, safe=safe)
6763
6764    def _parse_xml_table(self) -> exp.XMLTable:
6765        namespaces = None
6766        passing = None
6767        columns = None
6768
6769        if self._match_text_seq("XMLNAMESPACES", "("):
6770            namespaces = self._parse_xml_namespace()
6771            self._match_text_seq(")", ",")
6772
6773        this = self._parse_string()
6774
6775        if self._match_text_seq("PASSING"):
6776            # The BY VALUE keywords are optional and are provided for semantic clarity
6777            self._match_text_seq("BY", "VALUE")
6778            passing = self._parse_csv(self._parse_column)
6779
6780        by_ref = self._match_text_seq("RETURNING", "SEQUENCE", "BY", "REF")
6781
6782        if self._match_text_seq("COLUMNS"):
6783            columns = self._parse_csv(self._parse_field_def)
6784
6785        return self.expression(
6786            exp.XMLTable,
6787            this=this,
6788            namespaces=namespaces,
6789            passing=passing,
6790            columns=columns,
6791            by_ref=by_ref,
6792        )
6793
6794    def _parse_xml_namespace(self) -> t.List[exp.XMLNamespace]:
6795        namespaces = []
6796
6797        while True:
6798            if self._match(TokenType.DEFAULT):
6799                uri = self._parse_string()
6800            else:
6801                uri = self._parse_alias(self._parse_string())
6802            namespaces.append(self.expression(exp.XMLNamespace, this=uri))
6803            if not self._match(TokenType.COMMA):
6804                break
6805
6806        return namespaces
6807
6808    def _parse_decode(self) -> t.Optional[exp.Decode | exp.DecodeCase]:
6809        args = self._parse_csv(self._parse_assignment)
6810
6811        if len(args) < 3:
6812            return self.expression(exp.Decode, this=seq_get(args, 0), charset=seq_get(args, 1))
6813
6814        return self.expression(exp.DecodeCase, expressions=args)
6815
6816    def _parse_json_key_value(self) -> t.Optional[exp.JSONKeyValue]:
6817        self._match_text_seq("KEY")
6818        key = self._parse_column()
6819        self._match_set(self.JSON_KEY_VALUE_SEPARATOR_TOKENS)
6820        self._match_text_seq("VALUE")
6821        value = self._parse_bitwise()
6822
6823        if not key and not value:
6824            return None
6825        return self.expression(exp.JSONKeyValue, this=key, expression=value)
6826
6827    def _parse_format_json(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
6828        if not this or not self._match_text_seq("FORMAT", "JSON"):
6829            return this
6830
6831        return self.expression(exp.FormatJson, this=this)
6832
6833    def _parse_on_condition(self) -> t.Optional[exp.OnCondition]:
6834        # MySQL uses "X ON EMPTY Y ON ERROR" (e.g. JSON_VALUE) while Oracle uses the opposite (e.g. JSON_EXISTS)
6835        if self.dialect.ON_CONDITION_EMPTY_BEFORE_ERROR:
6836            empty = self._parse_on_handling("EMPTY", *self.ON_CONDITION_TOKENS)
6837            error = self._parse_on_handling("ERROR", *self.ON_CONDITION_TOKENS)
6838        else:
6839            error = self._parse_on_handling("ERROR", *self.ON_CONDITION_TOKENS)
6840            empty = self._parse_on_handling("EMPTY", *self.ON_CONDITION_TOKENS)
6841
6842        null = self._parse_on_handling("NULL", *self.ON_CONDITION_TOKENS)
6843
6844        if not empty and not error and not null:
6845            return None
6846
6847        return self.expression(
6848            exp.OnCondition,
6849            empty=empty,
6850            error=error,
6851            null=null,
6852        )
6853
6854    def _parse_on_handling(
6855        self, on: str, *values: str
6856    ) -> t.Optional[str] | t.Optional[exp.Expression]:
6857        # Parses the "X ON Y" or "DEFAULT <expr> ON Y syntax, e.g. NULL ON NULL (Oracle, T-SQL, MySQL)
6858        for value in values:
6859            if self._match_text_seq(value, "ON", on):
6860                return f"{value} ON {on}"
6861
6862        index = self._index
6863        if self._match(TokenType.DEFAULT):
6864            default_value = self._parse_bitwise()
6865            if self._match_text_seq("ON", on):
6866                return default_value
6867
6868            self._retreat(index)
6869
6870        return None
6871
6872    @t.overload
6873    def _parse_json_object(self, agg: Lit[False]) -> exp.JSONObject: ...
6874
6875    @t.overload
6876    def _parse_json_object(self, agg: Lit[True]) -> exp.JSONObjectAgg: ...
6877
6878    def _parse_json_object(self, agg=False):
6879        star = self._parse_star()
6880        expressions = (
6881            [star]
6882            if star
6883            else self._parse_csv(lambda: self._parse_format_json(self._parse_json_key_value()))
6884        )
6885        null_handling = self._parse_on_handling("NULL", "NULL", "ABSENT")
6886
6887        unique_keys = None
6888        if self._match_text_seq("WITH", "UNIQUE"):
6889            unique_keys = True
6890        elif self._match_text_seq("WITHOUT", "UNIQUE"):
6891            unique_keys = False
6892
6893        self._match_text_seq("KEYS")
6894
6895        return_type = self._match_text_seq("RETURNING") and self._parse_format_json(
6896            self._parse_type()
6897        )
6898        encoding = self._match_text_seq("ENCODING") and self._parse_var()
6899
6900        return self.expression(
6901            exp.JSONObjectAgg if agg else exp.JSONObject,
6902            expressions=expressions,
6903            null_handling=null_handling,
6904            unique_keys=unique_keys,
6905            return_type=return_type,
6906            encoding=encoding,
6907        )
6908
6909    # Note: this is currently incomplete; it only implements the "JSON_value_column" part
6910    def _parse_json_column_def(self) -> exp.JSONColumnDef:
6911        if not self._match_text_seq("NESTED"):
6912            this = self._parse_id_var()
6913            kind = self._parse_types(allow_identifiers=False)
6914            nested = None
6915        else:
6916            this = None
6917            kind = None
6918            nested = True
6919
6920        path = self._match_text_seq("PATH") and self._parse_string()
6921        nested_schema = nested and self._parse_json_schema()
6922
6923        return self.expression(
6924            exp.JSONColumnDef,
6925            this=this,
6926            kind=kind,
6927            path=path,
6928            nested_schema=nested_schema,
6929        )
6930
6931    def _parse_json_schema(self) -> exp.JSONSchema:
6932        self._match_text_seq("COLUMNS")
6933        return self.expression(
6934            exp.JSONSchema,
6935            expressions=self._parse_wrapped_csv(self._parse_json_column_def, optional=True),
6936        )
6937
6938    def _parse_json_table(self) -> exp.JSONTable:
6939        this = self._parse_format_json(self._parse_bitwise())
6940        path = self._match(TokenType.COMMA) and self._parse_string()
6941        error_handling = self._parse_on_handling("ERROR", "ERROR", "NULL")
6942        empty_handling = self._parse_on_handling("EMPTY", "ERROR", "NULL")
6943        schema = self._parse_json_schema()
6944
6945        return exp.JSONTable(
6946            this=this,
6947            schema=schema,
6948            path=path,
6949            error_handling=error_handling,
6950            empty_handling=empty_handling,
6951        )
6952
6953    def _parse_match_against(self) -> exp.MatchAgainst:
6954        if self._match_text_seq("TABLE"):
6955            # parse SingleStore MATCH(TABLE ...) syntax
6956            # https://docs.singlestore.com/cloud/reference/sql-reference/full-text-search-functions/match/
6957            expressions = []
6958            table = self._parse_table()
6959            if table:
6960                expressions = [table]
6961        else:
6962            expressions = self._parse_csv(self._parse_column)
6963
6964        self._match_text_seq(")", "AGAINST", "(")
6965
6966        this = self._parse_string()
6967
6968        if self._match_text_seq("IN", "NATURAL", "LANGUAGE", "MODE"):
6969            modifier = "IN NATURAL LANGUAGE MODE"
6970            if self._match_text_seq("WITH", "QUERY", "EXPANSION"):
6971                modifier = f"{modifier} WITH QUERY EXPANSION"
6972        elif self._match_text_seq("IN", "BOOLEAN", "MODE"):
6973            modifier = "IN BOOLEAN MODE"
6974        elif self._match_text_seq("WITH", "QUERY", "EXPANSION"):
6975            modifier = "WITH QUERY EXPANSION"
6976        else:
6977            modifier = None
6978
6979        return self.expression(
6980            exp.MatchAgainst, this=this, expressions=expressions, modifier=modifier
6981        )
6982
6983    # https://learn.microsoft.com/en-us/sql/t-sql/functions/openjson-transact-sql?view=sql-server-ver16
6984    def _parse_open_json(self) -> exp.OpenJSON:
6985        this = self._parse_bitwise()
6986        path = self._match(TokenType.COMMA) and self._parse_string()
6987
6988        def _parse_open_json_column_def() -> exp.OpenJSONColumnDef:
6989            this = self._parse_field(any_token=True)
6990            kind = self._parse_types()
6991            path = self._parse_string()
6992            as_json = self._match_pair(TokenType.ALIAS, TokenType.JSON)
6993
6994            return self.expression(
6995                exp.OpenJSONColumnDef, this=this, kind=kind, path=path, as_json=as_json
6996            )
6997
6998        expressions = None
6999        if self._match_pair(TokenType.R_PAREN, TokenType.WITH):
7000            self._match_l_paren()
7001            expressions = self._parse_csv(_parse_open_json_column_def)
7002
7003        return self.expression(exp.OpenJSON, this=this, path=path, expressions=expressions)
7004
7005    def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition:
7006        args = self._parse_csv(self._parse_bitwise)
7007
7008        if self._match(TokenType.IN):
7009            return self.expression(
7010                exp.StrPosition, this=self._parse_bitwise(), substr=seq_get(args, 0)
7011            )
7012
7013        if haystack_first:
7014            haystack = seq_get(args, 0)
7015            needle = seq_get(args, 1)
7016        else:
7017            haystack = seq_get(args, 1)
7018            needle = seq_get(args, 0)
7019
7020        return self.expression(
7021            exp.StrPosition, this=haystack, substr=needle, position=seq_get(args, 2)
7022        )
7023
7024    def _parse_join_hint(self, func_name: str) -> exp.JoinHint:
7025        args = self._parse_csv(self._parse_table)
7026        return exp.JoinHint(this=func_name.upper(), expressions=args)
7027
7028    def _parse_substring(self) -> exp.Substring:
7029        # Postgres supports the form: substring(string [from int] [for int])
7030        # (despite being undocumented, the reverse order also works)
7031        # https://www.postgresql.org/docs/9.1/functions-string.html @ Table 9-6
7032
7033        args = t.cast(t.List[t.Optional[exp.Expression]], self._parse_csv(self._parse_bitwise))
7034
7035        start, length = None, None
7036
7037        while self._curr:
7038            if self._match(TokenType.FROM):
7039                start = self._parse_bitwise()
7040            elif self._match(TokenType.FOR):
7041                if not start:
7042                    start = exp.Literal.number(1)
7043                length = self._parse_bitwise()
7044            else:
7045                break
7046
7047        if start:
7048            args.append(start)
7049        if length:
7050            args.append(length)
7051
7052        return self.validate_expression(exp.Substring.from_arg_list(args), args)
7053
7054    def _parse_trim(self) -> exp.Trim:
7055        # https://www.w3resource.com/sql/character-functions/trim.php
7056        # https://docs.oracle.com/javadb/10.8.3.0/ref/rreftrimfunc.html
7057
7058        position = None
7059        collation = None
7060        expression = None
7061
7062        if self._match_texts(self.TRIM_TYPES):
7063            position = self._prev.text.upper()
7064
7065        this = self._parse_bitwise()
7066        if self._match_set((TokenType.FROM, TokenType.COMMA)):
7067            invert_order = self._prev.token_type == TokenType.FROM or self.TRIM_PATTERN_FIRST
7068            expression = self._parse_bitwise()
7069
7070            if invert_order:
7071                this, expression = expression, this
7072
7073        if self._match(TokenType.COLLATE):
7074            collation = self._parse_bitwise()
7075
7076        return self.expression(
7077            exp.Trim, this=this, position=position, expression=expression, collation=collation
7078        )
7079
7080    def _parse_window_clause(self) -> t.Optional[t.List[exp.Expression]]:
7081        return self._match(TokenType.WINDOW) and self._parse_csv(self._parse_named_window)
7082
7083    def _parse_named_window(self) -> t.Optional[exp.Expression]:
7084        return self._parse_window(self._parse_id_var(), alias=True)
7085
7086    def _parse_respect_or_ignore_nulls(
7087        self, this: t.Optional[exp.Expression]
7088    ) -> t.Optional[exp.Expression]:
7089        if self._match_text_seq("IGNORE", "NULLS"):
7090            return self.expression(exp.IgnoreNulls, this=this)
7091        if self._match_text_seq("RESPECT", "NULLS"):
7092            return self.expression(exp.RespectNulls, this=this)
7093        return this
7094
7095    def _parse_having_max(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
7096        if self._match(TokenType.HAVING):
7097            self._match_texts(("MAX", "MIN"))
7098            max = self._prev.text.upper() != "MIN"
7099            return self.expression(
7100                exp.HavingMax, this=this, expression=self._parse_column(), max=max
7101            )
7102
7103        return this
7104
7105    def _parse_window(
7106        self, this: t.Optional[exp.Expression], alias: bool = False
7107    ) -> t.Optional[exp.Expression]:
7108        func = this
7109        comments = func.comments if isinstance(func, exp.Expression) else None
7110
7111        # T-SQL allows the OVER (...) syntax after WITHIN GROUP.
7112        # https://learn.microsoft.com/en-us/sql/t-sql/functions/percentile-disc-transact-sql?view=sql-server-ver16
7113        if self._match_text_seq("WITHIN", "GROUP"):
7114            order = self._parse_wrapped(self._parse_order)
7115            this = self.expression(exp.WithinGroup, this=this, expression=order)
7116
7117        if self._match_pair(TokenType.FILTER, TokenType.L_PAREN):
7118            self._match(TokenType.WHERE)
7119            this = self.expression(
7120                exp.Filter, this=this, expression=self._parse_where(skip_where_token=True)
7121            )
7122            self._match_r_paren()
7123
7124        # SQL spec defines an optional [ { IGNORE | RESPECT } NULLS ] OVER
7125        # Some dialects choose to implement and some do not.
7126        # https://dev.mysql.com/doc/refman/8.0/en/window-function-descriptions.html
7127
7128        # There is some code above in _parse_lambda that handles
7129        #   SELECT FIRST_VALUE(TABLE.COLUMN IGNORE|RESPECT NULLS) OVER ...
7130
7131        # The below changes handle
7132        #   SELECT FIRST_VALUE(TABLE.COLUMN) IGNORE|RESPECT NULLS OVER ...
7133
7134        # Oracle allows both formats
7135        #   (https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/img_text/first_value.html)
7136        #   and Snowflake chose to do the same for familiarity
7137        #   https://docs.snowflake.com/en/sql-reference/functions/first_value.html#usage-notes
7138        if isinstance(this, exp.AggFunc):
7139            ignore_respect = this.find(exp.IgnoreNulls, exp.RespectNulls)
7140
7141            if ignore_respect and ignore_respect is not this:
7142                ignore_respect.replace(ignore_respect.this)
7143                this = self.expression(ignore_respect.__class__, this=this)
7144
7145        this = self._parse_respect_or_ignore_nulls(this)
7146
7147        # bigquery select from window x AS (partition by ...)
7148        if alias:
7149            over = None
7150            self._match(TokenType.ALIAS)
7151        elif not self._match_set(self.WINDOW_BEFORE_PAREN_TOKENS):
7152            return this
7153        else:
7154            over = self._prev.text.upper()
7155
7156        if comments and isinstance(func, exp.Expression):
7157            func.pop_comments()
7158
7159        if not self._match(TokenType.L_PAREN):
7160            return self.expression(
7161                exp.Window,
7162                comments=comments,
7163                this=this,
7164                alias=self._parse_id_var(False),
7165                over=over,
7166            )
7167
7168        window_alias = self._parse_id_var(any_token=False, tokens=self.WINDOW_ALIAS_TOKENS)
7169
7170        first = self._match(TokenType.FIRST)
7171        if self._match_text_seq("LAST"):
7172            first = False
7173
7174        partition, order = self._parse_partition_and_order()
7175        kind = self._match_set((TokenType.ROWS, TokenType.RANGE)) and self._prev.text
7176
7177        if kind:
7178            self._match(TokenType.BETWEEN)
7179            start = self._parse_window_spec()
7180
7181            end = self._parse_window_spec() if self._match(TokenType.AND) else {}
7182            exclude = (
7183                self._parse_var_from_options(self.WINDOW_EXCLUDE_OPTIONS)
7184                if self._match_text_seq("EXCLUDE")
7185                else None
7186            )
7187
7188            spec = self.expression(
7189                exp.WindowSpec,
7190                kind=kind,
7191                start=start["value"],
7192                start_side=start["side"],
7193                end=end.get("value"),
7194                end_side=end.get("side"),
7195                exclude=exclude,
7196            )
7197        else:
7198            spec = None
7199
7200        self._match_r_paren()
7201
7202        window = self.expression(
7203            exp.Window,
7204            comments=comments,
7205            this=this,
7206            partition_by=partition,
7207            order=order,
7208            spec=spec,
7209            alias=window_alias,
7210            over=over,
7211            first=first,
7212        )
7213
7214        # This covers Oracle's FIRST/LAST syntax: aggregate KEEP (...) OVER (...)
7215        if self._match_set(self.WINDOW_BEFORE_PAREN_TOKENS, advance=False):
7216            return self._parse_window(window, alias=alias)
7217
7218        return window
7219
7220    def _parse_partition_and_order(
7221        self,
7222    ) -> t.Tuple[t.List[exp.Expression], t.Optional[exp.Expression]]:
7223        return self._parse_partition_by(), self._parse_order()
7224
7225    def _parse_window_spec(self) -> t.Dict[str, t.Optional[str | exp.Expression]]:
7226        self._match(TokenType.BETWEEN)
7227
7228        return {
7229            "value": (
7230                (self._match_text_seq("UNBOUNDED") and "UNBOUNDED")
7231                or (self._match_text_seq("CURRENT", "ROW") and "CURRENT ROW")
7232                or self._parse_type()
7233            ),
7234            "side": self._match_texts(self.WINDOW_SIDES) and self._prev.text,
7235        }
7236
7237    def _parse_alias(
7238        self, this: t.Optional[exp.Expression], explicit: bool = False
7239    ) -> t.Optional[exp.Expression]:
7240        # In some dialects, LIMIT and OFFSET can act as both identifiers and keywords (clauses)
7241        # so this section tries to parse the clause version and if it fails, it treats the token
7242        # as an identifier (alias)
7243        if self._can_parse_limit_or_offset():
7244            return this
7245
7246        any_token = self._match(TokenType.ALIAS)
7247        comments = self._prev_comments or []
7248
7249        if explicit and not any_token:
7250            return this
7251
7252        if self._match(TokenType.L_PAREN):
7253            aliases = self.expression(
7254                exp.Aliases,
7255                comments=comments,
7256                this=this,
7257                expressions=self._parse_csv(lambda: self._parse_id_var(any_token)),
7258            )
7259            self._match_r_paren(aliases)
7260            return aliases
7261
7262        alias = self._parse_id_var(any_token, tokens=self.ALIAS_TOKENS) or (
7263            self.STRING_ALIASES and self._parse_string_as_identifier()
7264        )
7265
7266        if alias:
7267            comments.extend(alias.pop_comments())
7268            this = self.expression(exp.Alias, comments=comments, this=this, alias=alias)
7269            column = this.this
7270
7271            # Moves the comment next to the alias in `expr /* comment */ AS alias`
7272            if not this.comments and column and column.comments:
7273                this.comments = column.pop_comments()
7274
7275        return this
7276
7277    def _parse_id_var(
7278        self,
7279        any_token: bool = True,
7280        tokens: t.Optional[t.Collection[TokenType]] = None,
7281    ) -> t.Optional[exp.Expression]:
7282        expression = self._parse_identifier()
7283        if not expression and (
7284            (any_token and self._advance_any()) or self._match_set(tokens or self.ID_VAR_TOKENS)
7285        ):
7286            quoted = self._prev.token_type == TokenType.STRING
7287            expression = self._identifier_expression(quoted=quoted)
7288
7289        return expression
7290
7291    def _parse_string(self) -> t.Optional[exp.Expression]:
7292        if self._match_set(self.STRING_PARSERS):
7293            return self.STRING_PARSERS[self._prev.token_type](self, self._prev)
7294        return self._parse_placeholder()
7295
7296    def _parse_string_as_identifier(self) -> t.Optional[exp.Identifier]:
7297        output = exp.to_identifier(self._match(TokenType.STRING) and self._prev.text, quoted=True)
7298        if output:
7299            output.update_positions(self._prev)
7300        return output
7301
7302    def _parse_number(self) -> t.Optional[exp.Expression]:
7303        if self._match_set(self.NUMERIC_PARSERS):
7304            return self.NUMERIC_PARSERS[self._prev.token_type](self, self._prev)
7305        return self._parse_placeholder()
7306
7307    def _parse_identifier(self) -> t.Optional[exp.Expression]:
7308        if self._match(TokenType.IDENTIFIER):
7309            return self._identifier_expression(quoted=True)
7310        return self._parse_placeholder()
7311
7312    def _parse_var(
7313        self,
7314        any_token: bool = False,
7315        tokens: t.Optional[t.Collection[TokenType]] = None,
7316        upper: bool = False,
7317    ) -> t.Optional[exp.Expression]:
7318        if (
7319            (any_token and self._advance_any())
7320            or self._match(TokenType.VAR)
7321            or (self._match_set(tokens) if tokens else False)
7322        ):
7323            return self.expression(
7324                exp.Var, this=self._prev.text.upper() if upper else self._prev.text
7325            )
7326        return self._parse_placeholder()
7327
7328    def _advance_any(self, ignore_reserved: bool = False) -> t.Optional[Token]:
7329        if self._curr and (ignore_reserved or self._curr.token_type not in self.RESERVED_TOKENS):
7330            self._advance()
7331            return self._prev
7332        return None
7333
7334    def _parse_var_or_string(self, upper: bool = False) -> t.Optional[exp.Expression]:
7335        return self._parse_string() or self._parse_var(any_token=True, upper=upper)
7336
7337    def _parse_primary_or_var(self) -> t.Optional[exp.Expression]:
7338        return self._parse_primary() or self._parse_var(any_token=True)
7339
7340    def _parse_null(self) -> t.Optional[exp.Expression]:
7341        if self._match_set((TokenType.NULL, TokenType.UNKNOWN)):
7342            return self.PRIMARY_PARSERS[TokenType.NULL](self, self._prev)
7343        return self._parse_placeholder()
7344
7345    def _parse_boolean(self) -> t.Optional[exp.Expression]:
7346        if self._match(TokenType.TRUE):
7347            return self.PRIMARY_PARSERS[TokenType.TRUE](self, self._prev)
7348        if self._match(TokenType.FALSE):
7349            return self.PRIMARY_PARSERS[TokenType.FALSE](self, self._prev)
7350        return self._parse_placeholder()
7351
7352    def _parse_star(self) -> t.Optional[exp.Expression]:
7353        if self._match(TokenType.STAR):
7354            return self.PRIMARY_PARSERS[TokenType.STAR](self, self._prev)
7355        return self._parse_placeholder()
7356
7357    def _parse_parameter(self) -> exp.Parameter:
7358        this = self._parse_identifier() or self._parse_primary_or_var()
7359        return self.expression(exp.Parameter, this=this)
7360
7361    def _parse_placeholder(self) -> t.Optional[exp.Expression]:
7362        if self._match_set(self.PLACEHOLDER_PARSERS):
7363            placeholder = self.PLACEHOLDER_PARSERS[self._prev.token_type](self)
7364            if placeholder:
7365                return placeholder
7366            self._advance(-1)
7367        return None
7368
7369    def _parse_star_op(self, *keywords: str) -> t.Optional[t.List[exp.Expression]]:
7370        if not self._match_texts(keywords):
7371            return None
7372        if self._match(TokenType.L_PAREN, advance=False):
7373            return self._parse_wrapped_csv(self._parse_expression)
7374
7375        expression = self._parse_alias(self._parse_assignment(), explicit=True)
7376        return [expression] if expression else None
7377
7378    def _parse_csv(
7379        self, parse_method: t.Callable, sep: TokenType = TokenType.COMMA
7380    ) -> t.List[exp.Expression]:
7381        parse_result = parse_method()
7382        items = [parse_result] if parse_result is not None else []
7383
7384        while self._match(sep):
7385            self._add_comments(parse_result)
7386            parse_result = parse_method()
7387            if parse_result is not None:
7388                items.append(parse_result)
7389
7390        return items
7391
7392    def _parse_tokens(
7393        self, parse_method: t.Callable, expressions: t.Dict
7394    ) -> t.Optional[exp.Expression]:
7395        this = parse_method()
7396
7397        while self._match_set(expressions):
7398            this = self.expression(
7399                expressions[self._prev.token_type],
7400                this=this,
7401                comments=self._prev_comments,
7402                expression=parse_method(),
7403            )
7404
7405        return this
7406
7407    def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]:
7408        return self._parse_wrapped_csv(self._parse_id_var, optional=optional)
7409
7410    def _parse_wrapped_csv(
7411        self, parse_method: t.Callable, sep: TokenType = TokenType.COMMA, optional: bool = False
7412    ) -> t.List[exp.Expression]:
7413        return self._parse_wrapped(
7414            lambda: self._parse_csv(parse_method, sep=sep), optional=optional
7415        )
7416
7417    def _parse_wrapped(self, parse_method: t.Callable, optional: bool = False) -> t.Any:
7418        wrapped = self._match(TokenType.L_PAREN)
7419        if not wrapped and not optional:
7420            self.raise_error("Expecting (")
7421        parse_result = parse_method()
7422        if wrapped:
7423            self._match_r_paren()
7424        return parse_result
7425
7426    def _parse_expressions(self) -> t.List[exp.Expression]:
7427        return self._parse_csv(self._parse_expression)
7428
7429    def _parse_select_or_expression(self, alias: bool = False) -> t.Optional[exp.Expression]:
7430        return (
7431            self._parse_set_operations(
7432                self._parse_alias(self._parse_assignment(), explicit=True)
7433                if alias
7434                else self._parse_assignment()
7435            )
7436            or self._parse_select()
7437        )
7438
7439    def _parse_ddl_select(self) -> t.Optional[exp.Expression]:
7440        return self._parse_query_modifiers(
7441            self._parse_set_operations(self._parse_select(nested=True, parse_subquery_alias=False))
7442        )
7443
7444    def _parse_transaction(self) -> exp.Transaction | exp.Command:
7445        this = None
7446        if self._match_texts(self.TRANSACTION_KIND):
7447            this = self._prev.text
7448
7449        self._match_texts(("TRANSACTION", "WORK"))
7450
7451        modes = []
7452        while True:
7453            mode = []
7454            while self._match(TokenType.VAR) or self._match(TokenType.NOT):
7455                mode.append(self._prev.text)
7456
7457            if mode:
7458                modes.append(" ".join(mode))
7459            if not self._match(TokenType.COMMA):
7460                break
7461
7462        return self.expression(exp.Transaction, this=this, modes=modes)
7463
7464    def _parse_commit_or_rollback(self) -> exp.Commit | exp.Rollback:
7465        chain = None
7466        savepoint = None
7467        is_rollback = self._prev.token_type == TokenType.ROLLBACK
7468
7469        self._match_texts(("TRANSACTION", "WORK"))
7470
7471        if self._match_text_seq("TO"):
7472            self._match_text_seq("SAVEPOINT")
7473            savepoint = self._parse_id_var()
7474
7475        if self._match(TokenType.AND):
7476            chain = not self._match_text_seq("NO")
7477            self._match_text_seq("CHAIN")
7478
7479        if is_rollback:
7480            return self.expression(exp.Rollback, savepoint=savepoint)
7481
7482        return self.expression(exp.Commit, chain=chain)
7483
7484    def _parse_refresh(self) -> exp.Refresh:
7485        self._match(TokenType.TABLE)
7486        return self.expression(exp.Refresh, this=self._parse_string() or self._parse_table())
7487
7488    def _parse_column_def_with_exists(self):
7489        start = self._index
7490        self._match(TokenType.COLUMN)
7491
7492        exists_column = self._parse_exists(not_=True)
7493        expression = self._parse_field_def()
7494
7495        if not isinstance(expression, exp.ColumnDef):
7496            self._retreat(start)
7497            return None
7498
7499        expression.set("exists", exists_column)
7500
7501        return expression
7502
7503    def _parse_add_column(self) -> t.Optional[exp.ColumnDef]:
7504        if not self._prev.text.upper() == "ADD":
7505            return None
7506
7507        expression = self._parse_column_def_with_exists()
7508        if not expression:
7509            return None
7510
7511        # https://docs.databricks.com/delta/update-schema.html#explicitly-update-schema-to-add-columns
7512        if self._match_texts(("FIRST", "AFTER")):
7513            position = self._prev.text
7514            column_position = self.expression(
7515                exp.ColumnPosition, this=self._parse_column(), position=position
7516            )
7517            expression.set("position", column_position)
7518
7519        return expression
7520
7521    def _parse_drop_column(self) -> t.Optional[exp.Drop | exp.Command]:
7522        drop = self._match(TokenType.DROP) and self._parse_drop()
7523        if drop and not isinstance(drop, exp.Command):
7524            drop.set("kind", drop.args.get("kind", "COLUMN"))
7525        return drop
7526
7527    # https://docs.aws.amazon.com/athena/latest/ug/alter-table-drop-partition.html
7528    def _parse_drop_partition(self, exists: t.Optional[bool] = None) -> exp.DropPartition:
7529        return self.expression(
7530            exp.DropPartition, expressions=self._parse_csv(self._parse_partition), exists=exists
7531        )
7532
7533    def _parse_alter_table_add(self) -> t.List[exp.Expression]:
7534        def _parse_add_alteration() -> t.Optional[exp.Expression]:
7535            self._match_text_seq("ADD")
7536            if self._match_set(self.ADD_CONSTRAINT_TOKENS, advance=False):
7537                return self.expression(
7538                    exp.AddConstraint, expressions=self._parse_csv(self._parse_constraint)
7539                )
7540
7541            column_def = self._parse_add_column()
7542            if isinstance(column_def, exp.ColumnDef):
7543                return column_def
7544
7545            exists = self._parse_exists(not_=True)
7546            if self._match_pair(TokenType.PARTITION, TokenType.L_PAREN, advance=False):
7547                return self.expression(
7548                    exp.AddPartition,
7549                    exists=exists,
7550                    this=self._parse_field(any_token=True),
7551                    location=self._match_text_seq("LOCATION", advance=False)
7552                    and self._parse_property(),
7553                )
7554
7555            return None
7556
7557        if not self._match_set(self.ADD_CONSTRAINT_TOKENS, advance=False) and (
7558            not self.dialect.ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN
7559            or self._match_text_seq("COLUMNS")
7560        ):
7561            schema = self._parse_schema()
7562
7563            return (
7564                ensure_list(schema)
7565                if schema
7566                else self._parse_csv(self._parse_column_def_with_exists)
7567            )
7568
7569        return self._parse_csv(_parse_add_alteration)
7570
7571    def _parse_alter_table_alter(self) -> t.Optional[exp.Expression]:
7572        if self._match_texts(self.ALTER_ALTER_PARSERS):
7573            return self.ALTER_ALTER_PARSERS[self._prev.text.upper()](self)
7574
7575        # Many dialects support the ALTER [COLUMN] syntax, so if there is no
7576        # keyword after ALTER we default to parsing this statement
7577        self._match(TokenType.COLUMN)
7578        column = self._parse_field(any_token=True)
7579
7580        if self._match_pair(TokenType.DROP, TokenType.DEFAULT):
7581            return self.expression(exp.AlterColumn, this=column, drop=True)
7582        if self._match_pair(TokenType.SET, TokenType.DEFAULT):
7583            return self.expression(exp.AlterColumn, this=column, default=self._parse_assignment())
7584        if self._match(TokenType.COMMENT):
7585            return self.expression(exp.AlterColumn, this=column, comment=self._parse_string())
7586        if self._match_text_seq("DROP", "NOT", "NULL"):
7587            return self.expression(
7588                exp.AlterColumn,
7589                this=column,
7590                drop=True,
7591                allow_null=True,
7592            )
7593        if self._match_text_seq("SET", "NOT", "NULL"):
7594            return self.expression(
7595                exp.AlterColumn,
7596                this=column,
7597                allow_null=False,
7598            )
7599
7600        if self._match_text_seq("SET", "VISIBLE"):
7601            return self.expression(exp.AlterColumn, this=column, visible="VISIBLE")
7602        if self._match_text_seq("SET", "INVISIBLE"):
7603            return self.expression(exp.AlterColumn, this=column, visible="INVISIBLE")
7604
7605        self._match_text_seq("SET", "DATA")
7606        self._match_text_seq("TYPE")
7607        return self.expression(
7608            exp.AlterColumn,
7609            this=column,
7610            dtype=self._parse_types(),
7611            collate=self._match(TokenType.COLLATE) and self._parse_term(),
7612            using=self._match(TokenType.USING) and self._parse_assignment(),
7613        )
7614
7615    def _parse_alter_diststyle(self) -> exp.AlterDistStyle:
7616        if self._match_texts(("ALL", "EVEN", "AUTO")):
7617            return self.expression(exp.AlterDistStyle, this=exp.var(self._prev.text.upper()))
7618
7619        self._match_text_seq("KEY", "DISTKEY")
7620        return self.expression(exp.AlterDistStyle, this=self._parse_column())
7621
7622    def _parse_alter_sortkey(self, compound: t.Optional[bool] = None) -> exp.AlterSortKey:
7623        if compound:
7624            self._match_text_seq("SORTKEY")
7625
7626        if self._match(TokenType.L_PAREN, advance=False):
7627            return self.expression(
7628                exp.AlterSortKey, expressions=self._parse_wrapped_id_vars(), compound=compound
7629            )
7630
7631        self._match_texts(("AUTO", "NONE"))
7632        return self.expression(
7633            exp.AlterSortKey, this=exp.var(self._prev.text.upper()), compound=compound
7634        )
7635
7636    def _parse_alter_table_drop(self) -> t.List[exp.Expression]:
7637        index = self._index - 1
7638
7639        partition_exists = self._parse_exists()
7640        if self._match(TokenType.PARTITION, advance=False):
7641            return self._parse_csv(lambda: self._parse_drop_partition(exists=partition_exists))
7642
7643        self._retreat(index)
7644        return self._parse_csv(self._parse_drop_column)
7645
7646    def _parse_alter_table_rename(self) -> t.Optional[exp.AlterRename | exp.RenameColumn]:
7647        if self._match(TokenType.COLUMN) or not self.ALTER_RENAME_REQUIRES_COLUMN:
7648            exists = self._parse_exists()
7649            old_column = self._parse_column()
7650            to = self._match_text_seq("TO")
7651            new_column = self._parse_column()
7652
7653            if old_column is None or to is None or new_column is None:
7654                return None
7655
7656            return self.expression(exp.RenameColumn, this=old_column, to=new_column, exists=exists)
7657
7658        self._match_text_seq("TO")
7659        return self.expression(exp.AlterRename, this=self._parse_table(schema=True))
7660
7661    def _parse_alter_table_set(self) -> exp.AlterSet:
7662        alter_set = self.expression(exp.AlterSet)
7663
7664        if self._match(TokenType.L_PAREN, advance=False) or self._match_text_seq(
7665            "TABLE", "PROPERTIES"
7666        ):
7667            alter_set.set("expressions", self._parse_wrapped_csv(self._parse_assignment))
7668        elif self._match_text_seq("FILESTREAM_ON", advance=False):
7669            alter_set.set("expressions", [self._parse_assignment()])
7670        elif self._match_texts(("LOGGED", "UNLOGGED")):
7671            alter_set.set("option", exp.var(self._prev.text.upper()))
7672        elif self._match_text_seq("WITHOUT") and self._match_texts(("CLUSTER", "OIDS")):
7673            alter_set.set("option", exp.var(f"WITHOUT {self._prev.text.upper()}"))
7674        elif self._match_text_seq("LOCATION"):
7675            alter_set.set("location", self._parse_field())
7676        elif self._match_text_seq("ACCESS", "METHOD"):
7677            alter_set.set("access_method", self._parse_field())
7678        elif self._match_text_seq("TABLESPACE"):
7679            alter_set.set("tablespace", self._parse_field())
7680        elif self._match_text_seq("FILE", "FORMAT") or self._match_text_seq("FILEFORMAT"):
7681            alter_set.set("file_format", [self._parse_field()])
7682        elif self._match_text_seq("STAGE_FILE_FORMAT"):
7683            alter_set.set("file_format", self._parse_wrapped_options())
7684        elif self._match_text_seq("STAGE_COPY_OPTIONS"):
7685            alter_set.set("copy_options", self._parse_wrapped_options())
7686        elif self._match_text_seq("TAG") or self._match_text_seq("TAGS"):
7687            alter_set.set("tag", self._parse_csv(self._parse_assignment))
7688        else:
7689            if self._match_text_seq("SERDE"):
7690                alter_set.set("serde", self._parse_field())
7691
7692            properties = self._parse_wrapped(self._parse_properties, optional=True)
7693            alter_set.set("expressions", [properties])
7694
7695        return alter_set
7696
7697    def _parse_alter_session(self) -> exp.AlterSession:
7698        """Parse ALTER SESSION SET/UNSET statements."""
7699        if self._match(TokenType.SET):
7700            expressions = self._parse_csv(lambda: self._parse_set_item_assignment())
7701            return self.expression(exp.AlterSession, expressions=expressions, unset=False)
7702
7703        self._match_text_seq("UNSET")
7704        expressions = self._parse_csv(
7705            lambda: self.expression(exp.SetItem, this=self._parse_id_var(any_token=True))
7706        )
7707        return self.expression(exp.AlterSession, expressions=expressions, unset=True)
7708
7709    def _parse_alter(self) -> exp.Alter | exp.Command:
7710        start = self._prev
7711
7712        alter_token = self._match_set(self.ALTERABLES) and self._prev
7713        if not alter_token:
7714            return self._parse_as_command(start)
7715
7716        exists = self._parse_exists()
7717        only = self._match_text_seq("ONLY")
7718
7719        if alter_token.token_type == TokenType.SESSION:
7720            this = None
7721            check = None
7722            cluster = None
7723        else:
7724            this = self._parse_table(schema=True)
7725            check = self._match_text_seq("WITH", "CHECK")
7726            cluster = self._parse_on_property() if self._match(TokenType.ON) else None
7727
7728            if self._next:
7729                self._advance()
7730
7731        parser = self.ALTER_PARSERS.get(self._prev.text.upper()) if self._prev else None
7732        if parser:
7733            actions = ensure_list(parser(self))
7734            not_valid = self._match_text_seq("NOT", "VALID")
7735            options = self._parse_csv(self._parse_property)
7736
7737            if not self._curr and actions:
7738                return self.expression(
7739                    exp.Alter,
7740                    this=this,
7741                    kind=alter_token.text.upper(),
7742                    exists=exists,
7743                    actions=actions,
7744                    only=only,
7745                    options=options,
7746                    cluster=cluster,
7747                    not_valid=not_valid,
7748                    check=check,
7749                )
7750
7751        return self._parse_as_command(start)
7752
7753    def _parse_analyze(self) -> exp.Analyze | exp.Command:
7754        start = self._prev
7755        # https://duckdb.org/docs/sql/statements/analyze
7756        if not self._curr:
7757            return self.expression(exp.Analyze)
7758
7759        options = []
7760        while self._match_texts(self.ANALYZE_STYLES):
7761            if self._prev.text.upper() == "BUFFER_USAGE_LIMIT":
7762                options.append(f"BUFFER_USAGE_LIMIT {self._parse_number()}")
7763            else:
7764                options.append(self._prev.text.upper())
7765
7766        this: t.Optional[exp.Expression] = None
7767        inner_expression: t.Optional[exp.Expression] = None
7768
7769        kind = self._curr and self._curr.text.upper()
7770
7771        if self._match(TokenType.TABLE) or self._match(TokenType.INDEX):
7772            this = self._parse_table_parts()
7773        elif self._match_text_seq("TABLES"):
7774            if self._match_set((TokenType.FROM, TokenType.IN)):
7775                kind = f"{kind} {self._prev.text.upper()}"
7776                this = self._parse_table(schema=True, is_db_reference=True)
7777        elif self._match_text_seq("DATABASE"):
7778            this = self._parse_table(schema=True, is_db_reference=True)
7779        elif self._match_text_seq("CLUSTER"):
7780            this = self._parse_table()
7781        # Try matching inner expr keywords before fallback to parse table.
7782        elif self._match_texts(self.ANALYZE_EXPRESSION_PARSERS):
7783            kind = None
7784            inner_expression = self.ANALYZE_EXPRESSION_PARSERS[self._prev.text.upper()](self)
7785        else:
7786            # Empty kind  https://prestodb.io/docs/current/sql/analyze.html
7787            kind = None
7788            this = self._parse_table_parts()
7789
7790        partition = self._try_parse(self._parse_partition)
7791        if not partition and self._match_texts(self.PARTITION_KEYWORDS):
7792            return self._parse_as_command(start)
7793
7794        # https://docs.starrocks.io/docs/sql-reference/sql-statements/cbo_stats/ANALYZE_TABLE/
7795        if self._match_text_seq("WITH", "SYNC", "MODE") or self._match_text_seq(
7796            "WITH", "ASYNC", "MODE"
7797        ):
7798            mode = f"WITH {self._tokens[self._index - 2].text.upper()} MODE"
7799        else:
7800            mode = None
7801
7802        if self._match_texts(self.ANALYZE_EXPRESSION_PARSERS):
7803            inner_expression = self.ANALYZE_EXPRESSION_PARSERS[self._prev.text.upper()](self)
7804
7805        properties = self._parse_properties()
7806        return self.expression(
7807            exp.Analyze,
7808            kind=kind,
7809            this=this,
7810            mode=mode,
7811            partition=partition,
7812            properties=properties,
7813            expression=inner_expression,
7814            options=options,
7815        )
7816
7817    # https://spark.apache.org/docs/3.5.1/sql-ref-syntax-aux-analyze-table.html
7818    def _parse_analyze_statistics(self) -> exp.AnalyzeStatistics:
7819        this = None
7820        kind = self._prev.text.upper()
7821        option = self._prev.text.upper() if self._match_text_seq("DELTA") else None
7822        expressions = []
7823
7824        if not self._match_text_seq("STATISTICS"):
7825            self.raise_error("Expecting token STATISTICS")
7826
7827        if self._match_text_seq("NOSCAN"):
7828            this = "NOSCAN"
7829        elif self._match(TokenType.FOR):
7830            if self._match_text_seq("ALL", "COLUMNS"):
7831                this = "FOR ALL COLUMNS"
7832            if self._match_texts("COLUMNS"):
7833                this = "FOR COLUMNS"
7834                expressions = self._parse_csv(self._parse_column_reference)
7835        elif self._match_text_seq("SAMPLE"):
7836            sample = self._parse_number()
7837            expressions = [
7838                self.expression(
7839                    exp.AnalyzeSample,
7840                    sample=sample,
7841                    kind=self._prev.text.upper() if self._match(TokenType.PERCENT) else None,
7842                )
7843            ]
7844
7845        return self.expression(
7846            exp.AnalyzeStatistics, kind=kind, option=option, this=this, expressions=expressions
7847        )
7848
7849    # https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ANALYZE.html
7850    def _parse_analyze_validate(self) -> exp.AnalyzeValidate:
7851        kind = None
7852        this = None
7853        expression: t.Optional[exp.Expression] = None
7854        if self._match_text_seq("REF", "UPDATE"):
7855            kind = "REF"
7856            this = "UPDATE"
7857            if self._match_text_seq("SET", "DANGLING", "TO", "NULL"):
7858                this = "UPDATE SET DANGLING TO NULL"
7859        elif self._match_text_seq("STRUCTURE"):
7860            kind = "STRUCTURE"
7861            if self._match_text_seq("CASCADE", "FAST"):
7862                this = "CASCADE FAST"
7863            elif self._match_text_seq("CASCADE", "COMPLETE") and self._match_texts(
7864                ("ONLINE", "OFFLINE")
7865            ):
7866                this = f"CASCADE COMPLETE {self._prev.text.upper()}"
7867                expression = self._parse_into()
7868
7869        return self.expression(exp.AnalyzeValidate, kind=kind, this=this, expression=expression)
7870
7871    def _parse_analyze_columns(self) -> t.Optional[exp.AnalyzeColumns]:
7872        this = self._prev.text.upper()
7873        if self._match_text_seq("COLUMNS"):
7874            return self.expression(exp.AnalyzeColumns, this=f"{this} {self._prev.text.upper()}")
7875        return None
7876
7877    def _parse_analyze_delete(self) -> t.Optional[exp.AnalyzeDelete]:
7878        kind = self._prev.text.upper() if self._match_text_seq("SYSTEM") else None
7879        if self._match_text_seq("STATISTICS"):
7880            return self.expression(exp.AnalyzeDelete, kind=kind)
7881        return None
7882
7883    def _parse_analyze_list(self) -> t.Optional[exp.AnalyzeListChainedRows]:
7884        if self._match_text_seq("CHAINED", "ROWS"):
7885            return self.expression(exp.AnalyzeListChainedRows, expression=self._parse_into())
7886        return None
7887
7888    # https://dev.mysql.com/doc/refman/8.4/en/analyze-table.html
7889    def _parse_analyze_histogram(self) -> exp.AnalyzeHistogram:
7890        this = self._prev.text.upper()
7891        expression: t.Optional[exp.Expression] = None
7892        expressions = []
7893        update_options = None
7894
7895        if self._match_text_seq("HISTOGRAM", "ON"):
7896            expressions = self._parse_csv(self._parse_column_reference)
7897            with_expressions = []
7898            while self._match(TokenType.WITH):
7899                # https://docs.starrocks.io/docs/sql-reference/sql-statements/cbo_stats/ANALYZE_TABLE/
7900                if self._match_texts(("SYNC", "ASYNC")):
7901                    if self._match_text_seq("MODE", advance=False):
7902                        with_expressions.append(f"{self._prev.text.upper()} MODE")
7903                        self._advance()
7904                else:
7905                    buckets = self._parse_number()
7906                    if self._match_text_seq("BUCKETS"):
7907                        with_expressions.append(f"{buckets} BUCKETS")
7908            if with_expressions:
7909                expression = self.expression(exp.AnalyzeWith, expressions=with_expressions)
7910
7911            if self._match_texts(("MANUAL", "AUTO")) and self._match(
7912                TokenType.UPDATE, advance=False
7913            ):
7914                update_options = self._prev.text.upper()
7915                self._advance()
7916            elif self._match_text_seq("USING", "DATA"):
7917                expression = self.expression(exp.UsingData, this=self._parse_string())
7918
7919        return self.expression(
7920            exp.AnalyzeHistogram,
7921            this=this,
7922            expressions=expressions,
7923            expression=expression,
7924            update_options=update_options,
7925        )
7926
7927    def _parse_merge(self) -> exp.Merge:
7928        self._match(TokenType.INTO)
7929        target = self._parse_table()
7930
7931        if target and self._match(TokenType.ALIAS, advance=False):
7932            target.set("alias", self._parse_table_alias())
7933
7934        self._match(TokenType.USING)
7935        using = self._parse_table()
7936
7937        self._match(TokenType.ON)
7938        on = self._parse_assignment()
7939
7940        return self.expression(
7941            exp.Merge,
7942            this=target,
7943            using=using,
7944            on=on,
7945            whens=self._parse_when_matched(),
7946            returning=self._parse_returning(),
7947        )
7948
7949    def _parse_when_matched(self) -> exp.Whens:
7950        whens = []
7951
7952        while self._match(TokenType.WHEN):
7953            matched = not self._match(TokenType.NOT)
7954            self._match_text_seq("MATCHED")
7955            source = (
7956                False
7957                if self._match_text_seq("BY", "TARGET")
7958                else self._match_text_seq("BY", "SOURCE")
7959            )
7960            condition = self._parse_assignment() if self._match(TokenType.AND) else None
7961
7962            self._match(TokenType.THEN)
7963
7964            if self._match(TokenType.INSERT):
7965                this = self._parse_star()
7966                if this:
7967                    then: t.Optional[exp.Expression] = self.expression(exp.Insert, this=this)
7968                else:
7969                    then = self.expression(
7970                        exp.Insert,
7971                        this=exp.var("ROW")
7972                        if self._match_text_seq("ROW")
7973                        else self._parse_value(values=False),
7974                        expression=self._match_text_seq("VALUES") and self._parse_value(),
7975                    )
7976            elif self._match(TokenType.UPDATE):
7977                expressions = self._parse_star()
7978                if expressions:
7979                    then = self.expression(exp.Update, expressions=expressions)
7980                else:
7981                    then = self.expression(
7982                        exp.Update,
7983                        expressions=self._match(TokenType.SET)
7984                        and self._parse_csv(self._parse_equality),
7985                    )
7986            elif self._match(TokenType.DELETE):
7987                then = self.expression(exp.Var, this=self._prev.text)
7988            else:
7989                then = self._parse_var_from_options(self.CONFLICT_ACTIONS)
7990
7991            whens.append(
7992                self.expression(
7993                    exp.When,
7994                    matched=matched,
7995                    source=source,
7996                    condition=condition,
7997                    then=then,
7998                )
7999            )
8000        return self.expression(exp.Whens, expressions=whens)
8001
8002    def _parse_show(self) -> t.Optional[exp.Expression]:
8003        parser = self._find_parser(self.SHOW_PARSERS, self.SHOW_TRIE)
8004        if parser:
8005            return parser(self)
8006        return self._parse_as_command(self._prev)
8007
8008    def _parse_set_item_assignment(
8009        self, kind: t.Optional[str] = None
8010    ) -> t.Optional[exp.Expression]:
8011        index = self._index
8012
8013        if kind in ("GLOBAL", "SESSION") and self._match_text_seq("TRANSACTION"):
8014            return self._parse_set_transaction(global_=kind == "GLOBAL")
8015
8016        left = self._parse_primary() or self._parse_column()
8017        assignment_delimiter = self._match_texts(("=", "TO"))
8018
8019        if not left or (self.SET_REQUIRES_ASSIGNMENT_DELIMITER and not assignment_delimiter):
8020            self._retreat(index)
8021            return None
8022
8023        right = self._parse_statement() or self._parse_id_var()
8024        if isinstance(right, (exp.Column, exp.Identifier)):
8025            right = exp.var(right.name)
8026
8027        this = self.expression(exp.EQ, this=left, expression=right)
8028        return self.expression(exp.SetItem, this=this, kind=kind)
8029
8030    def _parse_set_transaction(self, global_: bool = False) -> exp.Expression:
8031        self._match_text_seq("TRANSACTION")
8032        characteristics = self._parse_csv(
8033            lambda: self._parse_var_from_options(self.TRANSACTION_CHARACTERISTICS)
8034        )
8035        return self.expression(
8036            exp.SetItem,
8037            expressions=characteristics,
8038            kind="TRANSACTION",
8039            **{"global": global_},  # type: ignore
8040        )
8041
8042    def _parse_set_item(self) -> t.Optional[exp.Expression]:
8043        parser = self._find_parser(self.SET_PARSERS, self.SET_TRIE)
8044        return parser(self) if parser else self._parse_set_item_assignment(kind=None)
8045
8046    def _parse_set(self, unset: bool = False, tag: bool = False) -> exp.Set | exp.Command:
8047        index = self._index
8048        set_ = self.expression(
8049            exp.Set, expressions=self._parse_csv(self._parse_set_item), unset=unset, tag=tag
8050        )
8051
8052        if self._curr:
8053            self._retreat(index)
8054            return self._parse_as_command(self._prev)
8055
8056        return set_
8057
8058    def _parse_var_from_options(
8059        self, options: OPTIONS_TYPE, raise_unmatched: bool = True
8060    ) -> t.Optional[exp.Var]:
8061        start = self._curr
8062        if not start:
8063            return None
8064
8065        option = start.text.upper()
8066        continuations = options.get(option)
8067
8068        index = self._index
8069        self._advance()
8070        for keywords in continuations or []:
8071            if isinstance(keywords, str):
8072                keywords = (keywords,)
8073
8074            if self._match_text_seq(*keywords):
8075                option = f"{option} {' '.join(keywords)}"
8076                break
8077        else:
8078            if continuations or continuations is None:
8079                if raise_unmatched:
8080                    self.raise_error(f"Unknown option {option}")
8081
8082                self._retreat(index)
8083                return None
8084
8085        return exp.var(option)
8086
8087    def _parse_as_command(self, start: Token) -> exp.Command:
8088        while self._curr:
8089            self._advance()
8090        text = self._find_sql(start, self._prev)
8091        size = len(start.text)
8092        self._warn_unsupported()
8093        return exp.Command(this=text[:size], expression=text[size:])
8094
8095    def _parse_dict_property(self, this: str) -> exp.DictProperty:
8096        settings = []
8097
8098        self._match_l_paren()
8099        kind = self._parse_id_var()
8100
8101        if self._match(TokenType.L_PAREN):
8102            while True:
8103                key = self._parse_id_var()
8104                value = self._parse_primary()
8105                if not key and value is None:
8106                    break
8107                settings.append(self.expression(exp.DictSubProperty, this=key, value=value))
8108            self._match(TokenType.R_PAREN)
8109
8110        self._match_r_paren()
8111
8112        return self.expression(
8113            exp.DictProperty,
8114            this=this,
8115            kind=kind.this if kind else None,
8116            settings=settings,
8117        )
8118
8119    def _parse_dict_range(self, this: str) -> exp.DictRange:
8120        self._match_l_paren()
8121        has_min = self._match_text_seq("MIN")
8122        if has_min:
8123            min = self._parse_var() or self._parse_primary()
8124            self._match_text_seq("MAX")
8125            max = self._parse_var() or self._parse_primary()
8126        else:
8127            max = self._parse_var() or self._parse_primary()
8128            min = exp.Literal.number(0)
8129        self._match_r_paren()
8130        return self.expression(exp.DictRange, this=this, min=min, max=max)
8131
8132    def _parse_comprehension(
8133        self, this: t.Optional[exp.Expression]
8134    ) -> t.Optional[exp.Comprehension]:
8135        index = self._index
8136        expression = self._parse_column()
8137        if not self._match(TokenType.IN):
8138            self._retreat(index - 1)
8139            return None
8140        iterator = self._parse_column()
8141        condition = self._parse_assignment() if self._match_text_seq("IF") else None
8142        return self.expression(
8143            exp.Comprehension,
8144            this=this,
8145            expression=expression,
8146            iterator=iterator,
8147            condition=condition,
8148        )
8149
8150    def _parse_heredoc(self) -> t.Optional[exp.Heredoc]:
8151        if self._match(TokenType.HEREDOC_STRING):
8152            return self.expression(exp.Heredoc, this=self._prev.text)
8153
8154        if not self._match_text_seq("$"):
8155            return None
8156
8157        tags = ["$"]
8158        tag_text = None
8159
8160        if self._is_connected():
8161            self._advance()
8162            tags.append(self._prev.text.upper())
8163        else:
8164            self.raise_error("No closing $ found")
8165
8166        if tags[-1] != "$":
8167            if self._is_connected() and self._match_text_seq("$"):
8168                tag_text = tags[-1]
8169                tags.append("$")
8170            else:
8171                self.raise_error("No closing $ found")
8172
8173        heredoc_start = self._curr
8174
8175        while self._curr:
8176            if self._match_text_seq(*tags, advance=False):
8177                this = self._find_sql(heredoc_start, self._prev)
8178                self._advance(len(tags))
8179                return self.expression(exp.Heredoc, this=this, tag=tag_text)
8180
8181            self._advance()
8182
8183        self.raise_error(f"No closing {''.join(tags)} found")
8184        return None
8185
8186    def _find_parser(
8187        self, parsers: t.Dict[str, t.Callable], trie: t.Dict
8188    ) -> t.Optional[t.Callable]:
8189        if not self._curr:
8190            return None
8191
8192        index = self._index
8193        this = []
8194        while True:
8195            # The current token might be multiple words
8196            curr = self._curr.text.upper()
8197            key = curr.split(" ")
8198            this.append(curr)
8199
8200            self._advance()
8201            result, trie = in_trie(trie, key)
8202            if result == TrieResult.FAILED:
8203                break
8204
8205            if result == TrieResult.EXISTS:
8206                subparser = parsers[" ".join(this)]
8207                return subparser
8208
8209        self._retreat(index)
8210        return None
8211
8212    def _match(self, token_type, advance=True, expression=None):
8213        if not self._curr:
8214            return None
8215
8216        if self._curr.token_type == token_type:
8217            if advance:
8218                self._advance()
8219            self._add_comments(expression)
8220            return True
8221
8222        return None
8223
8224    def _match_set(self, types, advance=True):
8225        if not self._curr:
8226            return None
8227
8228        if self._curr.token_type in types:
8229            if advance:
8230                self._advance()
8231            return True
8232
8233        return None
8234
8235    def _match_pair(self, token_type_a, token_type_b, advance=True):
8236        if not self._curr or not self._next:
8237            return None
8238
8239        if self._curr.token_type == token_type_a and self._next.token_type == token_type_b:
8240            if advance:
8241                self._advance(2)
8242            return True
8243
8244        return None
8245
8246    def _match_l_paren(self, expression: t.Optional[exp.Expression] = None) -> None:
8247        if not self._match(TokenType.L_PAREN, expression=expression):
8248            self.raise_error("Expecting (")
8249
8250    def _match_r_paren(self, expression: t.Optional[exp.Expression] = None) -> None:
8251        if not self._match(TokenType.R_PAREN, expression=expression):
8252            self.raise_error("Expecting )")
8253
8254    def _match_texts(self, texts, advance=True):
8255        if (
8256            self._curr
8257            and self._curr.token_type != TokenType.STRING
8258            and self._curr.text.upper() in texts
8259        ):
8260            if advance:
8261                self._advance()
8262            return True
8263        return None
8264
8265    def _match_text_seq(self, *texts, advance=True):
8266        index = self._index
8267        for text in texts:
8268            if (
8269                self._curr
8270                and self._curr.token_type != TokenType.STRING
8271                and self._curr.text.upper() == text
8272            ):
8273                self._advance()
8274            else:
8275                self._retreat(index)
8276                return None
8277
8278        if not advance:
8279            self._retreat(index)
8280
8281        return True
8282
8283    def _replace_lambda(
8284        self, node: t.Optional[exp.Expression], expressions: t.List[exp.Expression]
8285    ) -> t.Optional[exp.Expression]:
8286        if not node:
8287            return node
8288
8289        lambda_types = {e.name: e.args.get("to") or False for e in expressions}
8290
8291        for column in node.find_all(exp.Column):
8292            typ = lambda_types.get(column.parts[0].name)
8293            if typ is not None:
8294                dot_or_id = column.to_dot() if column.table else column.this
8295
8296                if typ:
8297                    dot_or_id = self.expression(
8298                        exp.Cast,
8299                        this=dot_or_id,
8300                        to=typ,
8301                    )
8302
8303                parent = column.parent
8304
8305                while isinstance(parent, exp.Dot):
8306                    if not isinstance(parent.parent, exp.Dot):
8307                        parent.replace(dot_or_id)
8308                        break
8309                    parent = parent.parent
8310                else:
8311                    if column is node:
8312                        node = dot_or_id
8313                    else:
8314                        column.replace(dot_or_id)
8315        return node
8316
8317    def _parse_truncate_table(self) -> t.Optional[exp.TruncateTable] | exp.Expression:
8318        start = self._prev
8319
8320        # Not to be confused with TRUNCATE(number, decimals) function call
8321        if self._match(TokenType.L_PAREN):
8322            self._retreat(self._index - 2)
8323            return self._parse_function()
8324
8325        # Clickhouse supports TRUNCATE DATABASE as well
8326        is_database = self._match(TokenType.DATABASE)
8327
8328        self._match(TokenType.TABLE)
8329
8330        exists = self._parse_exists(not_=False)
8331
8332        expressions = self._parse_csv(
8333            lambda: self._parse_table(schema=True, is_db_reference=is_database)
8334        )
8335
8336        cluster = self._parse_on_property() if self._match(TokenType.ON) else None
8337
8338        if self._match_text_seq("RESTART", "IDENTITY"):
8339            identity = "RESTART"
8340        elif self._match_text_seq("CONTINUE", "IDENTITY"):
8341            identity = "CONTINUE"
8342        else:
8343            identity = None
8344
8345        if self._match_text_seq("CASCADE") or self._match_text_seq("RESTRICT"):
8346            option = self._prev.text
8347        else:
8348            option = None
8349
8350        partition = self._parse_partition()
8351
8352        # Fallback case
8353        if self._curr:
8354            return self._parse_as_command(start)
8355
8356        return self.expression(
8357            exp.TruncateTable,
8358            expressions=expressions,
8359            is_database=is_database,
8360            exists=exists,
8361            cluster=cluster,
8362            identity=identity,
8363            option=option,
8364            partition=partition,
8365        )
8366
8367    def _parse_with_operator(self) -> t.Optional[exp.Expression]:
8368        this = self._parse_ordered(self._parse_opclass)
8369
8370        if not self._match(TokenType.WITH):
8371            return this
8372
8373        op = self._parse_var(any_token=True)
8374
8375        return self.expression(exp.WithOperator, this=this, op=op)
8376
8377    def _parse_wrapped_options(self) -> t.List[t.Optional[exp.Expression]]:
8378        self._match(TokenType.EQ)
8379        self._match(TokenType.L_PAREN)
8380
8381        opts: t.List[t.Optional[exp.Expression]] = []
8382        option: exp.Expression | None
8383        while self._curr and not self._match(TokenType.R_PAREN):
8384            if self._match_text_seq("FORMAT_NAME", "="):
8385                # The FORMAT_NAME can be set to an identifier for Snowflake and T-SQL
8386                option = self._parse_format_name()
8387            else:
8388                option = self._parse_property()
8389
8390            if option is None:
8391                self.raise_error("Unable to parse option")
8392                break
8393
8394            opts.append(option)
8395
8396        return opts
8397
8398    def _parse_copy_parameters(self) -> t.List[exp.CopyParameter]:
8399        sep = TokenType.COMMA if self.dialect.COPY_PARAMS_ARE_CSV else None
8400
8401        options = []
8402        while self._curr and not self._match(TokenType.R_PAREN, advance=False):
8403            option = self._parse_var(any_token=True)
8404            prev = self._prev.text.upper()
8405
8406            # Different dialects might separate options and values by white space, "=" and "AS"
8407            self._match(TokenType.EQ)
8408            self._match(TokenType.ALIAS)
8409
8410            param = self.expression(exp.CopyParameter, this=option)
8411
8412            if prev in self.COPY_INTO_VARLEN_OPTIONS and self._match(
8413                TokenType.L_PAREN, advance=False
8414            ):
8415                # Snowflake FILE_FORMAT case, Databricks COPY & FORMAT options
8416                param.set("expressions", self._parse_wrapped_options())
8417            elif prev == "FILE_FORMAT":
8418                # T-SQL's external file format case
8419                param.set("expression", self._parse_field())
8420            else:
8421                param.set("expression", self._parse_unquoted_field())
8422
8423            options.append(param)
8424            self._match(sep)
8425
8426        return options
8427
8428    def _parse_credentials(self) -> t.Optional[exp.Credentials]:
8429        expr = self.expression(exp.Credentials)
8430
8431        if self._match_text_seq("STORAGE_INTEGRATION", "="):
8432            expr.set("storage", self._parse_field())
8433        if self._match_text_seq("CREDENTIALS"):
8434            # Snowflake case: CREDENTIALS = (...), Redshift case: CREDENTIALS <string>
8435            creds = (
8436                self._parse_wrapped_options() if self._match(TokenType.EQ) else self._parse_field()
8437            )
8438            expr.set("credentials", creds)
8439        if self._match_text_seq("ENCRYPTION"):
8440            expr.set("encryption", self._parse_wrapped_options())
8441        if self._match_text_seq("IAM_ROLE"):
8442            expr.set("iam_role", self._parse_field())
8443        if self._match_text_seq("REGION"):
8444            expr.set("region", self._parse_field())
8445
8446        return expr
8447
8448    def _parse_file_location(self) -> t.Optional[exp.Expression]:
8449        return self._parse_field()
8450
8451    def _parse_copy(self) -> exp.Copy | exp.Command:
8452        start = self._prev
8453
8454        self._match(TokenType.INTO)
8455
8456        this = (
8457            self._parse_select(nested=True, parse_subquery_alias=False)
8458            if self._match(TokenType.L_PAREN, advance=False)
8459            else self._parse_table(schema=True)
8460        )
8461
8462        kind = self._match(TokenType.FROM) or not self._match_text_seq("TO")
8463
8464        files = self._parse_csv(self._parse_file_location)
8465        if self._match(TokenType.EQ, advance=False):
8466            # Backtrack one token since we've consumed the lhs of a parameter assignment here.
8467            # This can happen for Snowflake dialect. Instead, we'd like to parse the parameter
8468            # list via `_parse_wrapped(..)` below.
8469            self._advance(-1)
8470            files = []
8471
8472        credentials = self._parse_credentials()
8473
8474        self._match_text_seq("WITH")
8475
8476        params = self._parse_wrapped(self._parse_copy_parameters, optional=True)
8477
8478        # Fallback case
8479        if self._curr:
8480            return self._parse_as_command(start)
8481
8482        return self.expression(
8483            exp.Copy,
8484            this=this,
8485            kind=kind,
8486            credentials=credentials,
8487            files=files,
8488            params=params,
8489        )
8490
8491    def _parse_normalize(self) -> exp.Normalize:
8492        return self.expression(
8493            exp.Normalize,
8494            this=self._parse_bitwise(),
8495            form=self._match(TokenType.COMMA) and self._parse_var(),
8496        )
8497
8498    def _parse_ceil_floor(self, expr_type: t.Type[TCeilFloor]) -> TCeilFloor:
8499        args = self._parse_csv(lambda: self._parse_lambda())
8500
8501        this = seq_get(args, 0)
8502        decimals = seq_get(args, 1)
8503
8504        return expr_type(
8505            this=this, decimals=decimals, to=self._match_text_seq("TO") and self._parse_var()
8506        )
8507
8508    def _parse_star_ops(self) -> t.Optional[exp.Expression]:
8509        star_token = self._prev
8510
8511        if self._match_text_seq("COLUMNS", "(", advance=False):
8512            this = self._parse_function()
8513            if isinstance(this, exp.Columns):
8514                this.set("unpack", True)
8515            return this
8516
8517        return self.expression(
8518            exp.Star,
8519            **{  # type: ignore
8520                "except": self._parse_star_op("EXCEPT", "EXCLUDE"),
8521                "replace": self._parse_star_op("REPLACE"),
8522                "rename": self._parse_star_op("RENAME"),
8523            },
8524        ).update_positions(star_token)
8525
8526    def _parse_grant_privilege(self) -> t.Optional[exp.GrantPrivilege]:
8527        privilege_parts = []
8528
8529        # Keep consuming consecutive keywords until comma (end of this privilege) or ON
8530        # (end of privilege list) or L_PAREN (start of column list) are met
8531        while self._curr and not self._match_set(self.PRIVILEGE_FOLLOW_TOKENS, advance=False):
8532            privilege_parts.append(self._curr.text.upper())
8533            self._advance()
8534
8535        this = exp.var(" ".join(privilege_parts))
8536        expressions = (
8537            self._parse_wrapped_csv(self._parse_column)
8538            if self._match(TokenType.L_PAREN, advance=False)
8539            else None
8540        )
8541
8542        return self.expression(exp.GrantPrivilege, this=this, expressions=expressions)
8543
8544    def _parse_grant_principal(self) -> t.Optional[exp.GrantPrincipal]:
8545        kind = self._match_texts(("ROLE", "GROUP")) and self._prev.text.upper()
8546        principal = self._parse_id_var()
8547
8548        if not principal:
8549            return None
8550
8551        return self.expression(exp.GrantPrincipal, this=principal, kind=kind)
8552
8553    def _parse_grant_revoke_common(
8554        self,
8555    ) -> t.Tuple[t.Optional[t.List], t.Optional[str], t.Optional[exp.Expression]]:
8556        privileges = self._parse_csv(self._parse_grant_privilege)
8557
8558        self._match(TokenType.ON)
8559        kind = self._match_set(self.CREATABLES) and self._prev.text.upper()
8560
8561        # Attempt to parse the securable e.g. MySQL allows names
8562        # such as "foo.*", "*.*" which are not easily parseable yet
8563        securable = self._try_parse(self._parse_table_parts)
8564
8565        return privileges, kind, securable
8566
8567    def _parse_grant(self) -> exp.Grant | exp.Command:
8568        start = self._prev
8569
8570        privileges, kind, securable = self._parse_grant_revoke_common()
8571
8572        if not securable or not self._match_text_seq("TO"):
8573            return self._parse_as_command(start)
8574
8575        principals = self._parse_csv(self._parse_grant_principal)
8576
8577        grant_option = self._match_text_seq("WITH", "GRANT", "OPTION")
8578
8579        if self._curr:
8580            return self._parse_as_command(start)
8581
8582        return self.expression(
8583            exp.Grant,
8584            privileges=privileges,
8585            kind=kind,
8586            securable=securable,
8587            principals=principals,
8588            grant_option=grant_option,
8589        )
8590
8591    def _parse_revoke(self) -> exp.Revoke | exp.Command:
8592        start = self._prev
8593
8594        grant_option = self._match_text_seq("GRANT", "OPTION", "FOR")
8595
8596        privileges, kind, securable = self._parse_grant_revoke_common()
8597
8598        if not securable or not self._match_text_seq("FROM"):
8599            return self._parse_as_command(start)
8600
8601        principals = self._parse_csv(self._parse_grant_principal)
8602
8603        cascade = None
8604        if self._match_texts(("CASCADE", "RESTRICT")):
8605            cascade = self._prev.text.upper()
8606
8607        if self._curr:
8608            return self._parse_as_command(start)
8609
8610        return self.expression(
8611            exp.Revoke,
8612            privileges=privileges,
8613            kind=kind,
8614            securable=securable,
8615            principals=principals,
8616            grant_option=grant_option,
8617            cascade=cascade,
8618        )
8619
8620    def _parse_overlay(self) -> exp.Overlay:
8621        return self.expression(
8622            exp.Overlay,
8623            **{  # type: ignore
8624                "this": self._parse_bitwise(),
8625                "expression": self._match_text_seq("PLACING") and self._parse_bitwise(),
8626                "from": self._match_text_seq("FROM") and self._parse_bitwise(),
8627                "for": self._match_text_seq("FOR") and self._parse_bitwise(),
8628            },
8629        )
8630
8631    def _parse_format_name(self) -> exp.Property:
8632        # Note: Although not specified in the docs, Snowflake does accept a string/identifier
8633        # for FILE_FORMAT = <format_name>
8634        return self.expression(
8635            exp.Property,
8636            this=exp.var("FORMAT_NAME"),
8637            value=self._parse_string() or self._parse_table_parts(),
8638        )
8639
8640    def _parse_max_min_by(self, expr_type: t.Type[exp.AggFunc]) -> exp.AggFunc:
8641        args: t.List[exp.Expression] = []
8642
8643        if self._match(TokenType.DISTINCT):
8644            args.append(self.expression(exp.Distinct, expressions=[self._parse_assignment()]))
8645            self._match(TokenType.COMMA)
8646
8647        args.extend(self._parse_csv(self._parse_assignment))
8648
8649        return self.expression(
8650            expr_type, this=seq_get(args, 0), expression=seq_get(args, 1), count=seq_get(args, 2)
8651        )
8652
8653    def _identifier_expression(
8654        self, token: t.Optional[Token] = None, **kwargs: t.Any
8655    ) -> exp.Identifier:
8656        token = token or self._prev
8657        expression = self.expression(exp.Identifier, this=token.text, **kwargs)
8658        expression.update_positions(token)
8659        return expression
8660
8661    def _build_pipe_cte(
8662        self,
8663        query: exp.Query,
8664        expressions: t.List[exp.Expression],
8665        alias_cte: t.Optional[exp.TableAlias] = None,
8666    ) -> exp.Select:
8667        new_cte: t.Optional[t.Union[str, exp.TableAlias]]
8668        if alias_cte:
8669            new_cte = alias_cte
8670        else:
8671            self._pipe_cte_counter += 1
8672            new_cte = f"__tmp{self._pipe_cte_counter}"
8673
8674        with_ = query.args.get("with")
8675        ctes = with_.pop() if with_ else None
8676
8677        new_select = exp.select(*expressions, copy=False).from_(new_cte, copy=False)
8678        if ctes:
8679            new_select.set("with", ctes)
8680
8681        return new_select.with_(new_cte, as_=query, copy=False)
8682
8683    def _parse_pipe_syntax_select(self, query: exp.Select) -> exp.Select:
8684        select = self._parse_select(consume_pipe=False)
8685        if not select:
8686            return query
8687
8688        return self._build_pipe_cte(
8689            query=query.select(*select.expressions, append=False), expressions=[exp.Star()]
8690        )
8691
8692    def _parse_pipe_syntax_limit(self, query: exp.Select) -> exp.Select:
8693        limit = self._parse_limit()
8694        offset = self._parse_offset()
8695        if limit:
8696            curr_limit = query.args.get("limit", limit)
8697            if curr_limit.expression.to_py() >= limit.expression.to_py():
8698                query.limit(limit, copy=False)
8699        if offset:
8700            curr_offset = query.args.get("offset")
8701            curr_offset = curr_offset.expression.to_py() if curr_offset else 0
8702            query.offset(exp.Literal.number(curr_offset + offset.expression.to_py()), copy=False)
8703
8704        return query
8705
8706    def _parse_pipe_syntax_aggregate_fields(self) -> t.Optional[exp.Expression]:
8707        this = self._parse_assignment()
8708        if self._match_text_seq("GROUP", "AND", advance=False):
8709            return this
8710
8711        this = self._parse_alias(this)
8712
8713        if self._match_set((TokenType.ASC, TokenType.DESC), advance=False):
8714            return self._parse_ordered(lambda: this)
8715
8716        return this
8717
8718    def _parse_pipe_syntax_aggregate_group_order_by(
8719        self, query: exp.Select, group_by_exists: bool = True
8720    ) -> exp.Select:
8721        expr = self._parse_csv(self._parse_pipe_syntax_aggregate_fields)
8722        aggregates_or_groups, orders = [], []
8723        for element in expr:
8724            if isinstance(element, exp.Ordered):
8725                this = element.this
8726                if isinstance(this, exp.Alias):
8727                    element.set("this", this.args["alias"])
8728                orders.append(element)
8729            else:
8730                this = element
8731            aggregates_or_groups.append(this)
8732
8733        if group_by_exists:
8734            query.select(*aggregates_or_groups, copy=False).group_by(
8735                *[projection.args.get("alias", projection) for projection in aggregates_or_groups],
8736                copy=False,
8737            )
8738        else:
8739            query.select(*aggregates_or_groups, append=False, copy=False)
8740
8741        if orders:
8742            return query.order_by(*orders, append=False, copy=False)
8743
8744        return query
8745
8746    def _parse_pipe_syntax_aggregate(self, query: exp.Select) -> exp.Select:
8747        self._match_text_seq("AGGREGATE")
8748        query = self._parse_pipe_syntax_aggregate_group_order_by(query, group_by_exists=False)
8749
8750        if self._match(TokenType.GROUP_BY) or (
8751            self._match_text_seq("GROUP", "AND") and self._match(TokenType.ORDER_BY)
8752        ):
8753            query = self._parse_pipe_syntax_aggregate_group_order_by(query)
8754
8755        return self._build_pipe_cte(query=query, expressions=[exp.Star()])
8756
8757    def _parse_pipe_syntax_set_operator(self, query: exp.Query) -> t.Optional[exp.Query]:
8758        first_setop = self.parse_set_operation(this=query)
8759        if not first_setop:
8760            return None
8761
8762        def _parse_and_unwrap_query() -> t.Optional[exp.Select]:
8763            expr = self._parse_paren()
8764            return expr.assert_is(exp.Subquery).unnest() if expr else None
8765
8766        first_setop.this.pop()
8767
8768        setops = [
8769            first_setop.expression.pop().assert_is(exp.Subquery).unnest(),
8770            *self._parse_csv(_parse_and_unwrap_query),
8771        ]
8772
8773        query = self._build_pipe_cte(query=query, expressions=[exp.Star()])
8774        with_ = query.args.get("with")
8775        ctes = with_.pop() if with_ else None
8776
8777        if isinstance(first_setop, exp.Union):
8778            query = query.union(*setops, copy=False, **first_setop.args)
8779        elif isinstance(first_setop, exp.Except):
8780            query = query.except_(*setops, copy=False, **first_setop.args)
8781        else:
8782            query = query.intersect(*setops, copy=False, **first_setop.args)
8783
8784        query.set("with", ctes)
8785
8786        return self._build_pipe_cte(query=query, expressions=[exp.Star()])
8787
8788    def _parse_pipe_syntax_join(self, query: exp.Query) -> t.Optional[exp.Query]:
8789        join = self._parse_join()
8790        if not join:
8791            return None
8792
8793        if isinstance(query, exp.Select):
8794            return query.join(join, copy=False)
8795
8796        return query
8797
8798    def _parse_pipe_syntax_pivot(self, query: exp.Select) -> exp.Select:
8799        pivots = self._parse_pivots()
8800        if not pivots:
8801            return query
8802
8803        from_ = query.args.get("from")
8804        if from_:
8805            from_.this.set("pivots", pivots)
8806
8807        return self._build_pipe_cte(query=query, expressions=[exp.Star()])
8808
8809    def _parse_pipe_syntax_extend(self, query: exp.Select) -> exp.Select:
8810        self._match_text_seq("EXTEND")
8811        query.select(*[exp.Star(), *self._parse_expressions()], append=False, copy=False)
8812        return self._build_pipe_cte(query=query, expressions=[exp.Star()])
8813
8814    def _parse_pipe_syntax_tablesample(self, query: exp.Select) -> exp.Select:
8815        sample = self._parse_table_sample()
8816
8817        with_ = query.args.get("with")
8818        if with_:
8819            with_.expressions[-1].this.set("sample", sample)
8820        else:
8821            query.set("sample", sample)
8822
8823        return query
8824
8825    def _parse_pipe_syntax_query(self, query: exp.Query) -> t.Optional[exp.Query]:
8826        if isinstance(query, exp.Subquery):
8827            query = exp.select("*").from_(query, copy=False)
8828
8829        if not query.args.get("from"):
8830            query = exp.select("*").from_(query.subquery(copy=False), copy=False)
8831
8832        while self._match(TokenType.PIPE_GT):
8833            start = self._curr
8834            parser = self.PIPE_SYNTAX_TRANSFORM_PARSERS.get(self._curr.text.upper())
8835            if not parser:
8836                # The set operators (UNION, etc) and the JOIN operator have a few common starting
8837                # keywords, making it tricky to disambiguate them without lookahead. The approach
8838                # here is to try and parse a set operation and if that fails, then try to parse a
8839                # join operator. If that fails as well, then the operator is not supported.
8840                parsed_query = self._parse_pipe_syntax_set_operator(query)
8841                parsed_query = parsed_query or self._parse_pipe_syntax_join(query)
8842                if not parsed_query:
8843                    self._retreat(start)
8844                    self.raise_error(f"Unsupported pipe syntax operator: '{start.text.upper()}'.")
8845                    break
8846                query = parsed_query
8847            else:
8848                query = parser(self, query)
8849
8850        return query
8851
8852    def _parse_declareitem(self) -> t.Optional[exp.DeclareItem]:
8853        vars = self._parse_csv(self._parse_id_var)
8854        if not vars:
8855            return None
8856
8857        return self.expression(
8858            exp.DeclareItem,
8859            this=vars,
8860            kind=self._parse_types(),
8861            default=self._match(TokenType.DEFAULT) and self._parse_bitwise(),
8862        )
8863
8864    def _parse_declare(self) -> exp.Declare | exp.Command:
8865        start = self._prev
8866        expressions = self._try_parse(lambda: self._parse_csv(self._parse_declareitem))
8867
8868        if not expressions or self._curr:
8869            return self._parse_as_command(start)
8870
8871        return self.expression(exp.Declare, expressions=expressions)
8872
8873    def build_cast(self, strict: bool, **kwargs) -> exp.Cast:
8874        exp_class = exp.Cast if strict else exp.TryCast
8875
8876        if exp_class == exp.TryCast:
8877            kwargs["requires_string"] = self.dialect.TRY_CAST_REQUIRES_STRING
8878
8879        return self.expression(exp_class, **kwargs)
8880
8881    def _parse_json_value(self) -> exp.JSONValue:
8882        this = self._parse_bitwise()
8883        self._match(TokenType.COMMA)
8884        path = self._parse_bitwise()
8885
8886        returning = self._match(TokenType.RETURNING) and self._parse_type()
8887
8888        return self.expression(
8889            exp.JSONValue,
8890            this=this,
8891            path=self.dialect.to_json_path(path),
8892            returning=returning,
8893            on_condition=self._parse_on_condition(),
8894        )
8895
8896    def _parse_group_concat(self) -> t.Optional[exp.Expression]:
8897        def concat_exprs(
8898            node: t.Optional[exp.Expression], exprs: t.List[exp.Expression]
8899        ) -> exp.Expression:
8900            if isinstance(node, exp.Distinct) and len(node.expressions) > 1:
8901                concat_exprs = [
8902                    self.expression(exp.Concat, expressions=node.expressions, safe=True)
8903                ]
8904                node.set("expressions", concat_exprs)
8905                return node
8906            if len(exprs) == 1:
8907                return exprs[0]
8908            return self.expression(exp.Concat, expressions=args, safe=True)
8909
8910        args = self._parse_csv(self._parse_lambda)
8911
8912        if args:
8913            order = args[-1] if isinstance(args[-1], exp.Order) else None
8914
8915            if order:
8916                # Order By is the last (or only) expression in the list and has consumed the 'expr' before it,
8917                # remove 'expr' from exp.Order and add it back to args
8918                args[-1] = order.this
8919                order.set("this", concat_exprs(order.this, args))
8920
8921            this = order or concat_exprs(args[0], args)
8922        else:
8923            this = None
8924
8925        separator = self._parse_field() if self._match(TokenType.SEPARATOR) else None
8926
8927        return self.expression(exp.GroupConcat, this=this, separator=separator)